Changeset 100789 in webkit

Timestamp:

Nov 18, 2011 10:36:17 AM (12 years ago)

Author:

igor.oliveira@openbossa.org

Message:

No'am Rosenthal <​noam.rosenthal@nokia.com>

WebKit2: Enable serializing of data types needed for cross-process accelerated compositing
​https://bugs.webkit.org/show_bug.cgi?id=61694

Add an ArgumentCoder for KeyframeValueList, and modify the TimingFunction ArgumentCoder to
allow encoding const TimingFunctions and not just RefPtr<TimingFunction>.

Reviewed by Simon Hausmann.

• Scripts/webkit2/messages.py:
• Shared/WebCoreArgumentCoders.cpp:

(CoreIPC::::encode):
(CoreIPC::::decode):

• Shared/WebCoreArgumentCoders.h:

Location:

trunk/Source/WebKit2

Files:

• ChangeLog (modified) (1 diff)
• Scripts/webkit2/messages.py (modified) (1 diff)
• Shared/WebCoreArgumentCoders.cpp (modified) (5 diffs)
• Shared/WebCoreArgumentCoders.h (modified) (3 diffs)

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2011-11-18 No'am Rosenthal  <noam.rosenthal@nokia.com>
+
+        WebKit2: Enable serializing of data types needed for cross-process accelerated compositing
+        https://bugs.webkit.org/show_bug.cgi?id=61694
+
+        Add an ArgumentCoder for KeyframeValueList, and modify the TimingFunction ArgumentCoder to
+        allow encoding const TimingFunctions and not just RefPtr<TimingFunction>.
+
+        Reviewed by Simon Hausmann.
+
+        * Scripts/webkit2/messages.py:
+        * Shared/WebCoreArgumentCoders.cpp:
+        (CoreIPC::::encode):
+        (CoreIPC::::decode):
+        * Shared/WebCoreArgumentCoders.h:
+
 2011-11-18  Kenneth Rohde Christiansen  <kenneth@webkit.org>
 

trunk/Source/WebKit2/Scripts/webkit2/messages.py

@@ -377 +377 @@
         'WebCore::CompositionUnderline': ['<WebCore/Editor.h>'],
         'WebCore::GrammarDetail': ['<WebCore/TextCheckerClient.h>'],
+        'WebCore::KeyframeValueList': ['<WebCore/GraphicsLayer.h>'],
         'WebCore::KeypressCommand': ['<WebCore/KeyboardEvent.h>'],
         'WebCore::FileChooserSettings': ['<WebCore/FileChooser.h>'],

trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp

@@ -36 +36 @@
 #include <WebCore/FileChooser.h>
 #include <WebCore/GraphicsContext.h>
+#include <WebCore/GraphicsLayer.h>
 #include <WebCore/Image.h>
 #include <WebCore/PluginData.h>
@@ -824 +825 @@
 void ArgumentCoder<RefPtr<TimingFunction> >::encode(ArgumentEncoder* encoder, const RefPtr<TimingFunction>& function)
 {
-    // We don't want to encode null-references.
-    ASSERT(function);
+    encode(encoder, function.get());
+}
+
+void ArgumentCoder<RefPtr<TimingFunction> >::encode(ArgumentEncoder* encoder, const WebCore::TimingFunction* function)
+{
+    if (!function) {
+        encoder->encodeInt32(WebCore::TimingFunction::LinearFunction);
+        return;
+    }
 
     encoder->encodeEnum(function->type());
@@ -832 +840 @@
         break;
     case TimingFunction::CubicBezierFunction: {
-        CubicBezierTimingFunction* cubicFunction = static_cast<CubicBezierTimingFunction*>(function.get());
+        const WebCore::CubicBezierTimingFunction* cubicFunction = static_cast<const WebCore::CubicBezierTimingFunction*>(function);
         encoder->encodeDouble(cubicFunction->x1());
         encoder->encodeDouble(cubicFunction->y1());
@@ -840 +848 @@
     }
     case TimingFunction::StepsFunction: {
-        StepsTimingFunction* stepsFunction = static_cast<StepsTimingFunction*>(function.get());
+        const WebCore::StepsTimingFunction* stepsFunction = static_cast<const WebCore::StepsTimingFunction*>(function);
         encoder->encodeInt32(stepsFunction->numberOfSteps());
         encoder->encodeBool(stepsFunction->stepAtStart());
@@ -1147 +1155 @@
     return true;
 }
+
+#if USE(ACCELERATED_COMPOSITING)
+
+void ArgumentCoder<KeyframeValueList>::encode(ArgumentEncoder* encoder, const WebCore::KeyframeValueList& keyframes)
+{
+    encoder->encodeUInt32(keyframes.size());
+    encoder->encodeInt32(keyframes.property());
+    for (size_t i = 0; i < keyframes.size(); ++i) {
+        const WebCore::AnimationValue* value = keyframes.at(i);
+        encoder->encodeFloat(value->keyTime());
+        ArgumentCoder<RefPtr<WebCore::TimingFunction> >::encode(encoder, value->timingFunction());
+        switch (keyframes.property()) {
+        case WebCore::AnimatedPropertyOpacity: {
+            const WebCore::FloatAnimationValue* floatValue = static_cast<const WebCore::FloatAnimationValue*>(value);
+            encoder->encodeFloat(floatValue->value());
+            break;
+        }
+        case WebCore::AnimatedPropertyWebkitTransform: {
+            const WebCore::TransformAnimationValue* transformValue = static_cast<const WebCore::TransformAnimationValue*>(value);
+            ArgumentCoder<WebCore::TransformOperations>::encode(encoder, *transformValue->value());
+            break;
+        }
+        default:
+            break;
+        }
+    }
+}
+
+bool ArgumentCoder<KeyframeValueList>::decode(ArgumentDecoder* decoder, WebCore::KeyframeValueList& keyframes)
+{
+    uint32_t size;
+    int32_t property;
+    if (!decoder->decodeUInt32(size))
+        return false;
+    if (!decoder->decodeInt32(property))
+        return false;
+
+    keyframes = WebCore::KeyframeValueList(WebCore::AnimatedPropertyID(property));
+
+    for (size_t i = 0; i < size; ++i) {
+        float keyTime;
+        RefPtr<WebCore::TimingFunction> timingFunction;
+        if (!decoder->decodeFloat(keyTime))
+            return false;
+        if (!ArgumentCoder<RefPtr<WebCore::TimingFunction> >::decode(decoder, timingFunction))
+            return false;
+
+        switch (property) {
+        case WebCore::AnimatedPropertyOpacity: {
+            float value;
+            if (!decoder->decodeFloat(value))
+                return false;
+            keyframes.insert(new WebCore::FloatAnimationValue(keyTime, value, timingFunction));
+            break;
+        }
+        case WebCore::AnimatedPropertyWebkitTransform: {
+            WebCore::TransformOperations value;
+            if (!ArgumentCoder<WebCore::TransformOperations>::decode(decoder, value))
+                return false;
+            keyframes.insert(new WebCore::TransformAnimationValue(keyTime, &value, timingFunction));
+            break;
+        }
+        default:
+            break;
+        }
+    }
+
+    return true;
+}
+
 #endif
 
+#endif
+
 } // namespace CoreIPC

trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.h

@@ -43 +43 @@
     class IntRect;
     class IntSize;
+    class KeyframeValueList;
     class ProtectionSpace;
     class ResourceError;
@@ -274 +275 @@
 template<> struct ArgumentCoder<RefPtr<WebCore::TimingFunction> > {
     static void encode(ArgumentEncoder*, const RefPtr<WebCore::TimingFunction>&);
+    static void encode(ArgumentEncoder*, const WebCore::TimingFunction*);
     static bool decode(ArgumentDecoder*, RefPtr<WebCore::TimingFunction>&);
 };
@@ -293 +295 @@
 #endif
 
+#if USE(ACCELERATED_COMPOSITING)
+template<> struct ArgumentCoder<WebCore::KeyframeValueList> {
+    static void encode(ArgumentEncoder*, const WebCore::KeyframeValueList& keyframes);
+    static bool decode(ArgumentDecoder*, WebCore::KeyframeValueList& keyframes);
+};
+#endif
+
 } // namespace CoreIPC