Attachment 169382 Details for Bug 98733 – Patch

[patch] Patch

bug-98733-20121018191934.patch (text/plain), 46.91 KB, created by Dongseong Hwang on 2012-10-18 03:20:57 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Dongseong Hwang

Created: 2012-10-18 03:20:57 PDT

Size: 46.91 KB

patch

obsolete

>Subversion Revision: 131653
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index c4ce01b7ee8cdaf7afe74d7f8e87b496ccf875c4..11f3680cfb3fadeb3c070a7a46846dd62f976283 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,18 @@
>+2012-10-12  Huang Dongsung  <luxtella@company100.net>
>+
>+        [WK2] Add CustomFilterOperation serialization in ArgumentCoder.
>+        https://bugs.webkit.org/show_bug.cgi?id=98733
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Change CustomFilterOperation::parameters() to const function, because
>+        this method is a getter and a const instance needs to call this method.
>+
>+        No new tests because there is no change in behavior.
>+
>+        * platform/graphics/filters/CustomFilterOperation.h:
>+        (WebCore::CustomFilterOperation::parameters):
>+
> 2012-10-16  Huang Dongsung  <luxtella@company100.net>
> 
>         [CSS Shaders] Implement all composite operators except destination and lighter.
>diff --git a/Source/WebKit2/ChangeLog b/Source/WebKit2/ChangeLog
>index 4229b70d4cd0525dbd1afa6f276e9861756043e5..4f1f7ec247b4fa5334f26fb47ccec8fa6cdf74d9 100644
>--- a/Source/WebKit2/ChangeLog
>+++ b/Source/WebKit2/ChangeLog
>@@ -1,3 +1,39 @@
>+2012-10-12  Huang Dongsung  <luxtella@company100.net>
>+
>+        [WK2] Add CustomFilterOperation serialization in ArgumentCoder.
>+        https://bugs.webkit.org/show_bug.cgi?id=98733
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add ArgumentCoders for CustomFilterOperation and all dependent classes.
>+        Coordinated Graphics will use this css shaders serialization when it enables CSS
>+        Shaders.
>+
>+        No new tests, code path is not activated yet.
>+
>+        * CMakeLists.txt:
>+        * Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp: Added.
>+        (CoreIPC):
>+        (CoreIPC::::encode):
>+        (CoreIPC::::decode):
>+        * Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h: Added.
>+        (WebCore):
>+        (CoreIPC):
>+        * Shared/CoordinatedGraphics/WebCustomFilterProgram.h: Added.
>+        (WebKit):
>+        (WebCustomFilterProgram):
>+            WebCustomFilterProgram is made to serialize the data of a
>+            StyleCustomFilterProgram to the UI process.
>+        (WebKit::WebCustomFilterProgram::create):
>+        (WebKit::WebCustomFilterProgram::WebCustomFilterProgram):
>+        * Shared/ShareableSurface.cpp:
>+        * Shared/WebCoreArgumentCoders.cpp:
>+        * Shared/WebCoreArgumentCoders.h:
>+        * Target.pri:
>+        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h:
>+        * WebKit2.pri:
>+        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp:
>+
> 2012-10-17  Christophe Dumez  <christophe.dumez@intel.com>
> 
>         [EFL][WK2] Compilation warning in Ewk_View when accelerated compositing is disabled
>diff --git a/Source/WebCore/platform/graphics/filters/CustomFilterOperation.h b/Source/WebCore/platform/graphics/filters/CustomFilterOperation.h
>index 788b3f01626b3f4af0520dd8c6f25af44a2540a3..0d64d236827786453d3eac7a46d705e944f213e6 100644
>--- a/Source/WebCore/platform/graphics/filters/CustomFilterOperation.h
>+++ b/Source/WebCore/platform/graphics/filters/CustomFilterOperation.h
>@@ -69,7 +69,7 @@ public:
>     
>     CustomFilterProgram* program() const { return m_program.get(); }
>     
>-    const CustomFilterParameterList& parameters() { return m_parameters; }
>+    const CustomFilterParameterList& parameters() const { return m_parameters; }
>     
>     unsigned meshRows() const { return m_meshRows; }
>     unsigned meshColumns() const { return m_meshColumns; }
>diff --git a/Source/WebKit2/CMakeLists.txt b/Source/WebKit2/CMakeLists.txt
>index 8564d98a9257c42c82928cb19596aea85b36c710..f161edca38bfa189f6524cf6ad10c14e5fba1307 100644
>--- a/Source/WebKit2/CMakeLists.txt
>+++ b/Source/WebKit2/CMakeLists.txt
>@@ -6,6 +6,7 @@ SET(WebKit2_INCLUDE_DIRECTORIES
>     "${WEBKIT2_DIR}/Shared"
>     "${WEBKIT2_DIR}/Shared/API"
>     "${WEBKIT2_DIR}/Shared/API/c"
>+    "${WEBKIT2_DIR}/Shared/CoordinatedGraphics"
>     "${WEBKIT2_DIR}/Shared/CoreIPCSupport"
>     "${WEBKIT2_DIR}/Shared/Plugins"
>     "${WEBKIT2_DIR}/Shared/Plugins/Netscape"
>@@ -212,6 +213,8 @@ SET(WebKit2_SOURCES
>     Shared/API/c/WKURLResponse.cpp
>     Shared/API/c/WKUserContentURLPattern.cpp
> 
>+    Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp
>+
>     Shared/Plugins/NPIdentifierData.cpp
>     Shared/Plugins/NPObjectMessageReceiver.cpp
>     Shared/Plugins/NPObjectProxy.cpp
>diff --git a/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp b/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..b3cfc63f9273ac22066addba04c034629c435e52
>--- /dev/null
>+++ b/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp
>@@ -0,0 +1,536 @@
>+/*
>+ * Copyright (C) 2011 Apple Inc. All rights reserved.
>+ * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
>+ * Copyright (C) 2012 Company 100, Inc.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "CoordinatedGraphicsArgumentCoders.h"
>+
>+#if USE(COORDINATED_GRAPHICS)
>+#include "WebCoreArgumentCoders.h"
>+#include <WebCore/Animation.h>
>+#include <WebCore/Color.h>
>+#include <WebCore/FloatPoint3D.h>
>+#include <WebCore/IntPoint.h>
>+#include <WebCore/Length.h>
>+#include <WebCore/TransformationMatrix.h>
>+
>+#if ENABLE(CSS_FILTERS)
>+#include <WebCore/FilterOperations.h>
>+#endif
>+
>+#if ENABLE(CSS_SHADERS)
>+#include "WebCustomFilterProgram.h"
>+#include <WebCore/CustomFilterArrayParameter.h>
>+#include <WebCore/CustomFilterNumberParameter.h>
>+#include <WebCore/CustomFilterOperation.h>
>+#include <WebCore/CustomFilterProgram.h>
>+#include <WebCore/CustomFilterTransformParameter.h>
>+#include <WebCore/IdentityTransformOperation.h>
>+#include <WebCore/Matrix3DTransformOperation.h>
>+#include <WebCore/MatrixTransformOperation.h>
>+#include <WebCore/PerspectiveTransformOperation.h>
>+#include <WebCore/RotateTransformOperation.h>
>+#include <WebCore/ScaleTransformOperation.h>
>+#include <WebCore/SkewTransformOperation.h>
>+#include <WebCore/TranslateTransformOperation.h>
>+#endif
>+
>+#if USE(GRAPHICS_SURFACE)
>+#include <WebCore/GraphicsSurface.h>
>+#endif
>+
>+using namespace WebCore;
>+using namespace WebKit;
>+
>+namespace CoreIPC {
>+
>+void ArgumentCoder<FloatPoint3D>::encode(ArgumentEncoder* encoder, const FloatPoint3D& floatPoint3D)
>+{
>+    SimpleArgumentCoder<FloatPoint3D>::encode(encoder, floatPoint3D);
>+}
>+
>+bool ArgumentCoder<FloatPoint3D>::decode(ArgumentDecoder* decoder, FloatPoint3D& floatPoint3D)
>+{
>+    return SimpleArgumentCoder<FloatPoint3D>::decode(decoder, floatPoint3D);
>+}
>+
>+void ArgumentCoder<Length>::encode(ArgumentEncoder* encoder, const Length& length)
>+{
>+    SimpleArgumentCoder<Length>::encode(encoder, length);
>+}
>+
>+bool ArgumentCoder<Length>::decode(ArgumentDecoder* decoder, Length& length)
>+{
>+    return SimpleArgumentCoder<Length>::decode(decoder, length);
>+}
>+
>+void ArgumentCoder<TransformationMatrix>::encode(ArgumentEncoder* encoder, const TransformationMatrix& transformationMatrix)
>+{
>+    SimpleArgumentCoder<TransformationMatrix>::encode(encoder, transformationMatrix);
>+}
>+
>+bool ArgumentCoder<TransformationMatrix>::decode(ArgumentDecoder* decoder, TransformationMatrix& transformationMatrix)
>+{
>+    return SimpleArgumentCoder<TransformationMatrix>::decode(decoder, transformationMatrix);
>+}
>+
>+#if ENABLE(CSS_FILTERS)
>+void ArgumentCoder<WebCore::FilterOperations>::encode(ArgumentEncoder* encoder, const WebCore::FilterOperations& filters)
>+{
>+    encoder->encodeUInt32(filters.size());
>+    for (size_t i = 0; i < filters.size(); ++i) {
>+        const FilterOperation* filter = filters.at(i);
>+        FilterOperation::OperationType type = filter->getOperationType();
>+        encoder->encodeEnum(type);
>+        switch (type) {
>+        case FilterOperation::GRAYSCALE:
>+        case FilterOperation::SEPIA:
>+        case FilterOperation::SATURATE:
>+        case FilterOperation::HUE_ROTATE:
>+            encoder->encodeDouble(static_cast<const BasicColorMatrixFilterOperation*>(filter)->amount());
>+            break;
>+        case FilterOperation::INVERT:
>+        case FilterOperation::BRIGHTNESS:
>+        case FilterOperation::CONTRAST:
>+        case FilterOperation::OPACITY:
>+            encoder->encodeDouble(static_cast<const BasicComponentTransferFilterOperation*>(filter)->amount());
>+            break;
>+        case FilterOperation::BLUR:
>+            ArgumentCoder<Length>::encode(encoder, static_cast<const BlurFilterOperation*>(filter)->stdDeviation());
>+            break;
>+        case FilterOperation::DROP_SHADOW: {
>+            const DropShadowFilterOperation* shadow = static_cast<const DropShadowFilterOperation*>(filter);
>+            ArgumentCoder<IntPoint>::encode(encoder, shadow->location());
>+            encoder->encodeInt32(shadow->stdDeviation());
>+            ArgumentCoder<Color>::encode(encoder, shadow->color());
>+            break;
>+        }
>+#if ENABLE(CSS_SHADERS)
>+        case FilterOperation::CUSTOM: {
>+            const CustomFilterOperation* customOperation = static_cast<const CustomFilterOperation*>(filter);
>+
>+            ASSERT(customOperation->program());
>+            RefPtr<CustomFilterProgram> program = customOperation->program();
>+            ASSERT(program->isLoaded());
>+            CustomFilterProgramInfo programInfo = program->programInfo();
>+            encoder->encode(programInfo.vertexShaderString());
>+            encoder->encode(programInfo.fragmentShaderString());
>+            encoder->encodeEnum(program->programType());
>+            CustomFilterProgramMixSettings mixSettings = programInfo.mixSettings();
>+            encoder->encodeEnum(mixSettings.blendMode);
>+            encoder->encodeEnum(mixSettings.compositeOperator);
>+
>+            CustomFilterParameterList parameters = customOperation->parameters();
>+            encoder->encodeUInt32(parameters.size());
>+            for (size_t i = 0; i < parameters.size(); ++i) {
>+                RefPtr<CustomFilterParameter> parameter = parameters[i];
>+                encoder->encode(parameter->name());
>+                encoder->encodeEnum(parameter->parameterType());
>+
>+                switch (parameter->parameterType()) {
>+                case CustomFilterParameter::ARRAY: {
>+                    CustomFilterArrayParameter* arrayParameter = static_cast<CustomFilterArrayParameter*>(parameter.get());
>+                    encoder->encodeUInt32(arrayParameter->size());
>+                    for (size_t j = 0; j < arrayParameter->size(); ++j)
>+                        encoder->encode(arrayParameter->valueAt(j));
>+                    break;
>+                }
>+                case CustomFilterParameter::NUMBER: {
>+                    CustomFilterNumberParameter* nubmerParameter = static_cast<CustomFilterNumberParameter*>(parameter.get());
>+                    encoder->encodeUInt32(nubmerParameter->size());
>+                    for (size_t j = 0; j < nubmerParameter->size(); ++j)
>+                        encoder->encode(nubmerParameter->valueAt(j));
>+                    break;
>+                }
>+                case CustomFilterParameter::TRANSFORM: {
>+                    CustomFilterTransformParameter* transformParameter = static_cast<CustomFilterTransformParameter*>(parameter.get());
>+                    ArgumentCoder<TransformOperations>::encode(encoder, transformParameter->operations());
>+                    break;
>+                }
>+                }
>+            }
>+
>+            encoder->encode(customOperation->meshRows());
>+            encoder->encode(customOperation->meshColumns());
>+            encoder->encodeEnum(customOperation->meshBoxType());
>+            encoder->encodeEnum(customOperation->meshType());
>+            break;
>+        }
>+#endif
>+        default:
>+            break;
>+        }
>+    }
>+}
>+
>+bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder, WebCore::FilterOperations& filters)
>+{
>+    uint32_t size;
>+    if (!decoder->decodeUInt32(size))
>+        return false;
>+
>+    Vector<RefPtr<FilterOperation> >& operations = filters.operations();
>+
>+    for (size_t i = 0; i < size; ++i) {
>+        FilterOperation::OperationType type;
>+        RefPtr<FilterOperation> filter;
>+        if (!decoder->decodeEnum(type))
>+            return false;
>+
>+        switch (type) {
>+        case FilterOperation::GRAYSCALE:
>+        case FilterOperation::SEPIA:
>+        case FilterOperation::SATURATE:
>+        case FilterOperation::HUE_ROTATE: {
>+            double value;
>+            if (!decoder->decodeDouble(value))
>+                return false;
>+            filter = BasicColorMatrixFilterOperation::create(value, type);
>+            break;
>+        }
>+        case FilterOperation::INVERT:
>+        case FilterOperation::BRIGHTNESS:
>+        case FilterOperation::CONTRAST:
>+        case FilterOperation::OPACITY: {
>+            double value;
>+            if (!decoder->decodeDouble(value))
>+                return false;
>+            filter = BasicComponentTransferFilterOperation::create(value, type);
>+            break;
>+        }
>+        case FilterOperation::BLUR: {
>+            Length length;
>+            if (!ArgumentCoder<Length>::decode(decoder, length))
>+                return false;
>+            filter = BlurFilterOperation::create(length, type);
>+            break;
>+        }
>+        case FilterOperation::DROP_SHADOW: {
>+            IntPoint location;
>+            int32_t stdDeviation;
>+            Color color;
>+            if (!ArgumentCoder<IntPoint>::decode(decoder, location))
>+                return false;
>+            if (!decoder->decodeInt32(stdDeviation))
>+                return false;
>+            if (!ArgumentCoder<Color>::decode(decoder, color))
>+                return false;
>+            filter = DropShadowFilterOperation::create(location, stdDeviation, color, type);
>+            break;
>+        }
>+#if ENABLE(CSS_SHADERS)
>+        case FilterOperation::CUSTOM: {
>+            String vertexShaderString;
>+            String fragmentShaderString;
>+            CustomFilterProgramType programType;
>+            CustomFilterProgramMixSettings mixSettings;
>+            if (!decoder->decode(vertexShaderString))
>+                return false;
>+            if (!decoder->decode(fragmentShaderString))
>+                return false;
>+            if (!decoder->decodeEnum(programType))
>+                return false;
>+            if (!decoder->decodeEnum(mixSettings.blendMode))
>+                return false;
>+            if (!decoder->decodeEnum(mixSettings.compositeOperator))
>+                return false;
>+            RefPtr<CustomFilterProgram> program = WebCustomFilterProgram::create(vertexShaderString, fragmentShaderString, programType, mixSettings);
>+
>+            uint32_t parametersSize;
>+            if (!decoder->decodeUInt32(parametersSize))
>+                return false;
>+
>+            CustomFilterParameterList parameters(parametersSize);
>+            for (size_t i = 0; i < parametersSize; ++i) {
>+                String name;
>+                CustomFilterParameter::ParameterType parameterType;
>+                if (!decoder->decode(name))
>+                    return false;
>+                if (!decoder->decodeEnum(parameterType))
>+                    return false;
>+
>+                switch (parameterType) {
>+                case CustomFilterParameter::ARRAY: {
>+                    RefPtr<CustomFilterArrayParameter> arrayParameter = CustomFilterArrayParameter::create(name);
>+                    parameters.append(arrayParameter);
>+                    uint32_t arrayParameterSize;
>+                    if (!decoder->decodeUInt32(arrayParameterSize))
>+                        return false;
>+                    double arrayParameterValue;
>+                    for (size_t j = 0; j < arrayParameterSize; ++j) {
>+                        if (!decoder->decode(arrayParameterValue))
>+                            return false;
>+                        arrayParameter->addValue(arrayParameterValue);
>+                    }
>+                    break;
>+                }
>+                case CustomFilterParameter::NUMBER: {
>+                    RefPtr<CustomFilterNumberParameter> numberParameter = CustomFilterNumberParameter::create(name);
>+                    parameters.append(numberParameter);
>+                    uint32_t numberParameterSize;
>+                    if (!decoder->decodeUInt32(numberParameterSize))
>+                        return false;
>+                    double numberParameterValue;
>+                    for (size_t j = 0; j < numberParameterSize; ++j) {
>+                        if (!decoder->decode(numberParameterValue))
>+                            return false;
>+                        numberParameter->addValue(numberParameterValue);
>+                    }
>+                    break;
>+                }
>+                case CustomFilterParameter::TRANSFORM: {
>+                    RefPtr<CustomFilterTransformParameter> transformParameter = CustomFilterTransformParameter::create(name);
>+                    parameters.append(transformParameter);
>+                    TransformOperations operations;
>+                    if (!ArgumentCoder<TransformOperations>::decode(decoder, operations))
>+                        return false;
>+                    transformParameter->setOperations(operations);
>+                    break;
>+                }
>+                }
>+            }
>+
>+            unsigned meshRows;
>+            unsigned meshColumns;
>+            CustomFilterOperation::MeshBoxType meshBoxType;
>+            CustomFilterOperation::MeshType meshType;
>+            if (!decoder->decode(meshRows))
>+                return false;
>+            if (!decoder->decode(meshColumns))
>+                return false;
>+            if (!decoder->decodeEnum(meshBoxType))
>+                return false;
>+            if (!decoder->decodeEnum(meshType))
>+                return false;
>+
>+            filter = CustomFilterOperation::create(program, parameters, meshRows, meshColumns, meshBoxType, meshType);
>+            break;
>+        }
>+#endif
>+        default:
>+            break;
>+        }
>+
>+        if (filter)
>+            operations.append(filter);
>+    }
>+
>+    return true;
>+}
>+#endif
>+
>+#if ENABLE(CSS_SHADERS)
>+void ArgumentCoder<TransformOperations>::encode(ArgumentEncoder* encoder, const TransformOperations& transformOperations)
>+{
>+    encoder->encodeUInt32(transformOperations.size());
>+    for (size_t i = 0; i < transformOperations.size(); ++i) {
>+        const TransformOperation* operation = transformOperations.at(i);
>+        encoder->encodeEnum(operation->getOperationType());
>+
>+        switch (operation->getOperationType()) {
>+        case TransformOperation::SCALE_X:
>+        case TransformOperation::SCALE_Y:
>+        case TransformOperation::SCALE:
>+        case TransformOperation::SCALE_Z:
>+        case TransformOperation::SCALE_3D:
>+            encoder->encode(static_cast<const ScaleTransformOperation*>(operation)->x());
>+            encoder->encode(static_cast<const ScaleTransformOperation*>(operation)->y());
>+            encoder->encode(static_cast<const ScaleTransformOperation*>(operation)->z());
>+            break;
>+        case TransformOperation::TRANSLATE_X:
>+        case TransformOperation::TRANSLATE_Y:
>+        case TransformOperation::TRANSLATE:
>+        case TransformOperation::TRANSLATE_Z:
>+        case TransformOperation::TRANSLATE_3D:
>+            ArgumentCoder<Length>::encode(encoder, static_cast<const TranslateTransformOperation*>(operation)->x());
>+            ArgumentCoder<Length>::encode(encoder, static_cast<const TranslateTransformOperation*>(operation)->y());
>+            ArgumentCoder<Length>::encode(encoder, static_cast<const TranslateTransformOperation*>(operation)->z());
>+            break;
>+        case TransformOperation::ROTATE:
>+        case TransformOperation::ROTATE_X:
>+        case TransformOperation::ROTATE_Y:
>+        case TransformOperation::ROTATE_3D:
>+            encoder->encode(static_cast<const RotateTransformOperation*>(operation)->x());
>+            encoder->encode(static_cast<const RotateTransformOperation*>(operation)->y());
>+            encoder->encode(static_cast<const RotateTransformOperation*>(operation)->z());
>+            encoder->encode(static_cast<const RotateTransformOperation*>(operation)->angle());
>+            break;
>+        case TransformOperation::SKEW_X:
>+        case TransformOperation::SKEW_Y:
>+        case TransformOperation::SKEW:
>+            encoder->encode(static_cast<const SkewTransformOperation*>(operation)->angleX());
>+            encoder->encode(static_cast<const SkewTransformOperation*>(operation)->angleY());
>+            break;
>+        case TransformOperation::MATRIX:
>+            ArgumentCoder<TransformationMatrix>::encode(encoder, static_cast<const MatrixTransformOperation*>(operation)->matrix());
>+            break;
>+        case TransformOperation::MATRIX_3D:
>+            ArgumentCoder<TransformationMatrix>::encode(encoder, static_cast<const Matrix3DTransformOperation*>(operation)->matrix());
>+            break;
>+        case TransformOperation::PERSPECTIVE:
>+            ArgumentCoder<Length>::encode(encoder, static_cast<const PerspectiveTransformOperation*>(operation)->perspective());
>+            break;
>+        case TransformOperation::IDENTITY:
>+            break;
>+        case TransformOperation::NONE:
>+            ASSERT_NOT_REACHED();
>+            break;
>+        }
>+    }
>+}
>+
>+bool ArgumentCoder<TransformOperations>::decode(ArgumentDecoder* decoder, TransformOperations& transformOperations)
>+{
>+    uint32_t operationsSize;
>+    if (!decoder->decodeUInt32(operationsSize))
>+        return false;
>+
>+    for (size_t i = 0; i < operationsSize; ++i) {
>+        TransformOperation::OperationType operationType;
>+        if (!decoder->decodeEnum(operationType))
>+            return false;
>+
>+        switch (operationType) {
>+        case TransformOperation::SCALE_X:
>+        case TransformOperation::SCALE_Y:
>+        case TransformOperation::SCALE:
>+        case TransformOperation::SCALE_Z:
>+        case TransformOperation::SCALE_3D: {
>+            double x, y, z;
>+            if (!decoder->decode(x))
>+                return false;
>+            if (!decoder->decode(y))
>+                return false;
>+            if (!decoder->decode(z))
>+                return false;
>+            transformOperations.operations().append(ScaleTransformOperation::create(x, y, z, operationType));
>+            break;
>+        }
>+        case TransformOperation::TRANSLATE_X:
>+        case TransformOperation::TRANSLATE_Y:
>+        case TransformOperation::TRANSLATE:
>+        case TransformOperation::TRANSLATE_Z:
>+        case TransformOperation::TRANSLATE_3D: {
>+            Length x, y, z;
>+            if (!ArgumentCoder<Length>::decode(decoder, x))
>+                return false;
>+            if (!ArgumentCoder<Length>::decode(decoder, y))
>+                return false;
>+            if (!ArgumentCoder<Length>::decode(decoder, z))
>+                return false;
>+            transformOperations.operations().append(TranslateTransformOperation::create(x, y, z, operationType));
>+            break;
>+        }
>+        case TransformOperation::ROTATE:
>+        case TransformOperation::ROTATE_X:
>+        case TransformOperation::ROTATE_Y:
>+        case TransformOperation::ROTATE_3D: {
>+            double x, y, z, angle;
>+            if (!decoder->decode(x))
>+                return false;
>+            if (!decoder->decode(y))
>+                return false;
>+            if (!decoder->decode(z))
>+                return false;
>+            if (!decoder->decode(angle))
>+                return false;
>+            transformOperations.operations().append(RotateTransformOperation::create(x, y, z, angle, operationType));
>+            break;
>+        }
>+        case TransformOperation::SKEW_X:
>+        case TransformOperation::SKEW_Y:
>+        case TransformOperation::SKEW: {
>+            double angleX, angleY;
>+            if (!decoder->decode(angleX))
>+                return false;
>+            if (!decoder->decode(angleY))
>+                return false;
>+            transformOperations.operations().append(SkewTransformOperation::create(angleX, angleY, operationType));
>+            break;
>+        }
>+        case TransformOperation::MATRIX: {
>+            TransformationMatrix matrix;
>+            if (!ArgumentCoder<TransformationMatrix>::decode(decoder, matrix))
>+                return false;
>+            transformOperations.operations().append(MatrixTransformOperation::create(matrix));
>+            break;
>+        }
>+        case TransformOperation::MATRIX_3D: {
>+            TransformationMatrix matrix;
>+            if (!ArgumentCoder<TransformationMatrix>::decode(decoder, matrix))
>+                return false;
>+            transformOperations.operations().append(Matrix3DTransformOperation::create(matrix));
>+            break;
>+        }
>+        case TransformOperation::PERSPECTIVE: {
>+            Length perspective;
>+            if (!ArgumentCoder<Length>::decode(decoder, perspective))
>+                return false;
>+            transformOperations.operations().append(PerspectiveTransformOperation::create(perspective));
>+            break;
>+        }
>+        case TransformOperation::IDENTITY:
>+            transformOperations.operations().append(IdentityTransformOperation::create());
>+            break;
>+        case TransformOperation::NONE:
>+            ASSERT_NOT_REACHED();
>+            break;
>+        }
>+    }
>+    return true;
>+}
>+#endif
>+
>+#if USE(GRAPHICS_SURFACE)
>+void ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode(ArgumentEncoder* encoder, const WebCore::GraphicsSurfaceToken& token)
>+{
>+#if OS(DARWIN)
>+    encoder->encodeUInt32(token.frontBufferHandle);
>+    encoder->encodeUInt32(token.backBufferHandle);
>+#endif
>+#if OS(LINUX)
>+    encoder->encodeUInt32(token.frontBufferHandle);
>+#endif
>+}
>+
>+bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(ArgumentDecoder* decoder, WebCore::GraphicsSurfaceToken& token)
>+{
>+#if OS(DARWIN)
>+    if (!decoder->decodeUInt32(token.frontBufferHandle))
>+        return false;
>+    if (!decoder->decodeUInt32(token.backBufferHandle))
>+        return false;
>+#endif
>+#if OS(LINUX)
>+    if (!decoder->decodeUInt32(token.frontBufferHandle))
>+        return false;
>+#endif
>+    return true;
>+}
>+#endif
>+
>+} // namespace CoreIPC
>+#endif // USE(COORDINATED_GRAPHICS)
>diff --git a/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h b/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..87b4c5fe7529c57becefa621d8b911a161e21482
>--- /dev/null
>+++ b/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h
>@@ -0,0 +1,93 @@
>+/*
>+ * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
>+ * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
>+ * Copyright (C) 2012 Company 100, Inc.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#ifndef CoordinatedGraphicsArgumentCoders_h
>+#define CoordinatedGraphicsArgumentCoders_h
>+
>+#if USE(COORDINATED_GRAPHICS)
>+#include "ArgumentCoders.h"
>+
>+namespace WebCore {
>+class FloatPoint3D;
>+class TransformationMatrix;
>+struct Length;
>+
>+#if ENABLE(CSS_FILTERS)
>+class FilterOperations;
>+#endif
>+
>+#if ENABLE(CSS_SHADERS)
>+class TransformOperations;
>+#endif
>+
>+#if USE(GRAPHICS_SURFACE)
>+struct GraphicsSurfaceToken;
>+#endif
>+}
>+
>+namespace CoreIPC {
>+
>+template<> struct ArgumentCoder<WebCore::FloatPoint3D> {
>+    static void encode(ArgumentEncoder*, const WebCore::FloatPoint3D&);
>+    static bool decode(ArgumentDecoder*, WebCore::FloatPoint3D&);
>+};
>+
>+template<> struct ArgumentCoder<WebCore::Length> {
>+    static void encode(ArgumentEncoder*, const WebCore::Length&);
>+    static bool decode(ArgumentDecoder*, WebCore::Length&);
>+};
>+
>+template<> struct ArgumentCoder<WebCore::TransformationMatrix> {
>+    static void encode(ArgumentEncoder*, const WebCore::TransformationMatrix&);
>+    static bool decode(ArgumentDecoder*, WebCore::TransformationMatrix&);
>+};
>+
>+#if ENABLE(CSS_FILTERS)
>+template<> struct ArgumentCoder<WebCore::FilterOperations> {
>+    static void encode(ArgumentEncoder*, const WebCore::FilterOperations&);
>+    static bool decode(ArgumentDecoder*, WebCore::FilterOperations&);
>+};
>+#endif
>+
>+#if ENABLE(CSS_SHADERS)
>+template<> struct ArgumentCoder<WebCore::TransformOperations> {
>+    static void encode(ArgumentEncoder*, const WebCore::TransformOperations&);
>+    static bool decode(ArgumentDecoder*, WebCore::TransformOperations&);
>+};
>+#endif
>+
>+#if USE(GRAPHICS_SURFACE)
>+template<> struct ArgumentCoder<WebCore::GraphicsSurfaceToken> {
>+    static void encode(ArgumentEncoder*, const WebCore::GraphicsSurfaceToken&);
>+    static bool decode(ArgumentDecoder*, WebCore::GraphicsSurfaceToken&);
>+};
>+#endif
>+
>+} // namespace CoreIPC
>+#endif // USE(COORDINATED_GRAPHICS)
>+
>+#endif // CoordinatedGraphicsArgumentCoders_h
>diff --git a/Source/WebKit2/Shared/CoordinatedGraphics/WebCustomFilterProgram.h b/Source/WebKit2/Shared/CoordinatedGraphics/WebCustomFilterProgram.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..eb097c2951976c2ebd6a76bd73c42197937fedee
>--- /dev/null
>+++ b/Source/WebKit2/Shared/CoordinatedGraphics/WebCustomFilterProgram.h
>@@ -0,0 +1,73 @@
>+/*
>+ * Copyright (C) 2012 Company 100, Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#ifndef WebCustomFilterProgram_h
>+#define WebCustomFilterProgram_h
>+
>+#if USE(COORDINATED_GRAPHICS) && ENABLE(CSS_SHADERS)
>+#include <WebCore/CustomFilterProgram.h>
>+
>+namespace WebKit {
>+
>+class WebCustomFilterProgram : public WebCore::CustomFilterProgram {
>+public:
>+    static PassRefPtr<WebCustomFilterProgram> create(String vertexShaderString, String m_fragmentShaderString, WebCore::CustomFilterProgramType programType, WebCore::CustomFilterProgramMixSettings mixSettings)
>+    {
>+        return adoptRef(new WebCustomFilterProgram(vertexShaderString, m_fragmentShaderString, programType, mixSettings));
>+    }
>+
>+    virtual bool isLoaded() const OVERRIDE { return true; }
>+
>+    virtual bool operator==(const CustomFilterProgram& o) const OVERRIDE
>+    {
>+        // The following cast is ugly, but WebCustomFilterProgram is the single implementation of CustomFilterProgram on UI Process.
>+        const WebCustomFilterProgram* other = static_cast<const WebCustomFilterProgram*>(&o);
>+        return mixSettings() == other->mixSettings() && m_vertexShaderString == other->vertexShaderString() && m_fragmentShaderString == other->fragmentShaderString();
>+    }
>+
>+protected:
>+    virtual String vertexShaderString() const OVERRIDE { return m_vertexShaderString; }
>+    virtual String fragmentShaderString() const OVERRIDE { return m_fragmentShaderString; }
>+
>+    virtual void willHaveClients() OVERRIDE { notifyClients(); }
>+    virtual void didRemoveLastClient() OVERRIDE { }
>+
>+private:
>+    WebCustomFilterProgram(String vertexShaderString, String fragmentShaderString, WebCore::CustomFilterProgramType programType, WebCore::CustomFilterProgramMixSettings mixSettings)
>+        : WebCore::CustomFilterProgram(programType, mixSettings)
>+        , m_vertexShaderString(vertexShaderString)
>+        , m_fragmentShaderString(fragmentShaderString)
>+    {
>+    }
>+
>+    String m_vertexShaderString;
>+    String m_fragmentShaderString;
>+};
>+
>+} // namespace WebKit
>+
>+#endif // USE(COORDINATED_GRAPHICS) && ENABLE(CSS_SHADERS)
>+
>+#endif // WebCustomFilterProgram_h
>diff --git a/Source/WebKit2/Shared/ShareableSurface.cpp b/Source/WebKit2/Shared/ShareableSurface.cpp
>index 136b0931134e4a0887f33806cff60bf0e2ba3aad..672816fc4903a2d9e3486d9c889712713d229ac3 100644
>--- a/Source/WebKit2/Shared/ShareableSurface.cpp
>+++ b/Source/WebKit2/Shared/ShareableSurface.cpp
>@@ -20,6 +20,7 @@
> #include "config.h"
> #include "ShareableSurface.h"
> 
>+#include "CoordinatedGraphicsArgumentCoders.h"
> #include "GraphicsContext.h"
> #include "WebCoreArgumentCoders.h"
> #include <WebCore/GraphicsSurfaceToken.h>
>diff --git a/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp b/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp
>index c25ea95116074da56dfae23476aaa4fcd6b17e4e..fa1cffada814a31798d0c87e8da980bb3f03de41 100644
>--- a/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp
>+++ b/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp
>@@ -51,20 +51,6 @@
> #include <WebCore/WindowFeatures.h>
> #include <wtf/text/StringHash.h>
> 
>-#if USE(COORDINATED_GRAPHICS)
>-#include <WebCore/Animation.h>
>-#include <WebCore/FloatPoint3D.h>
>-#include <WebCore/Length.h>
>-#include <WebCore/TransformationMatrix.h>
>-
>-#if ENABLE(CSS_FILTERS)
>-#include <WebCore/FilterOperations.h>
>-#endif
>-#if USE(GRAPHICS_SURFACE)
>-#include <WebCore/GraphicsSurface.h>
>-#endif
>-#endif
>-
> using namespace WebCore;
> using namespace WebKit;
> 
>@@ -874,172 +860,6 @@ bool ArgumentCoder<KURL>::decode(ArgumentDecoder* decoder, KURL& result)
>     return true;
> }
> 
>-#if USE(COORDINATED_GRAPHICS)
>-void ArgumentCoder<FloatPoint3D>::encode(ArgumentEncoder* encoder, const FloatPoint3D& floatPoint3D)
>-{
>-    SimpleArgumentCoder<FloatPoint3D>::encode(encoder, floatPoint3D);
>-}
>-
>-bool ArgumentCoder<FloatPoint3D>::decode(ArgumentDecoder* decoder, FloatPoint3D& floatPoint3D)
>-{
>-    return SimpleArgumentCoder<FloatPoint3D>::decode(decoder, floatPoint3D);
>-}
>-
>-void ArgumentCoder<Length>::encode(ArgumentEncoder* encoder, const Length& length)
>-{
>-    SimpleArgumentCoder<Length>::encode(encoder, length);
>-}
>-
>-bool ArgumentCoder<Length>::decode(ArgumentDecoder* decoder, Length& length)
>-{
>-    return SimpleArgumentCoder<Length>::decode(decoder, length);
>-}
>-
>-void ArgumentCoder<TransformationMatrix>::encode(ArgumentEncoder* encoder, const TransformationMatrix& transformationMatrix)
>-{
>-    SimpleArgumentCoder<TransformationMatrix>::encode(encoder, transformationMatrix);
>-}
>-
>-bool ArgumentCoder<TransformationMatrix>::decode(ArgumentDecoder* decoder, TransformationMatrix& transformationMatrix)
>-{
>-    return SimpleArgumentCoder<TransformationMatrix>::decode(decoder, transformationMatrix);
>-}
>-
>-#if ENABLE(CSS_FILTERS)
>-void ArgumentCoder<WebCore::FilterOperations>::encode(ArgumentEncoder* encoder, const WebCore::FilterOperations& filters)
>-{
>-    encoder->encodeUInt32(filters.size());
>-    for (size_t i = 0; i < filters.size(); ++i) {
>-        const FilterOperation* filter = filters.at(i);
>-        FilterOperation::OperationType type = filter->getOperationType();
>-        encoder->encodeEnum(type);
>-        switch (type) {
>-        case FilterOperation::GRAYSCALE:
>-        case FilterOperation::SEPIA:
>-        case FilterOperation::SATURATE:
>-        case FilterOperation::HUE_ROTATE:
>-            encoder->encodeDouble(static_cast<const BasicColorMatrixFilterOperation*>(filter)->amount());
>-            break;
>-        case FilterOperation::INVERT:
>-        case FilterOperation::BRIGHTNESS:
>-        case FilterOperation::CONTRAST:
>-        case FilterOperation::OPACITY:
>-            encoder->encodeDouble(static_cast<const BasicComponentTransferFilterOperation*>(filter)->amount());
>-            break;
>-        case FilterOperation::BLUR:
>-            ArgumentCoder<Length>::encode(encoder, static_cast<const BlurFilterOperation*>(filter)->stdDeviation());
>-            break;
>-        case FilterOperation::DROP_SHADOW: {
>-            const DropShadowFilterOperation* shadow = static_cast<const DropShadowFilterOperation*>(filter);
>-            ArgumentCoder<IntPoint>::encode(encoder, shadow->location());
>-            encoder->encodeInt32(shadow->stdDeviation());
>-            ArgumentCoder<Color>::encode(encoder, shadow->color());
>-            break;
>-        }
>-        default:
>-            break;
>-        }
>-    }
>-}
>-
>-bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder, WebCore::FilterOperations& filters)
>-{
>-    uint32_t size;
>-    if (!decoder->decodeUInt32(size))
>-        return false;
>-
>-    Vector<RefPtr<FilterOperation> >& operations = filters.operations();
>-
>-    for (size_t i = 0; i < size; ++i) {
>-        FilterOperation::OperationType type;
>-        RefPtr<FilterOperation> filter;
>-        if (!decoder->decodeEnum(type))
>-            return false;
>-
>-        switch (type) {
>-        case FilterOperation::GRAYSCALE:
>-        case FilterOperation::SEPIA:
>-        case FilterOperation::SATURATE:
>-        case FilterOperation::HUE_ROTATE: {
>-            double value;
>-            if (!decoder->decodeDouble(value))
>-                return false;
>-            filter = BasicColorMatrixFilterOperation::create(value, type);
>-            break;
>-        }
>-        case FilterOperation::INVERT:
>-        case FilterOperation::BRIGHTNESS:
>-        case FilterOperation::CONTRAST:
>-        case FilterOperation::OPACITY: {
>-            double value;
>-            if (!decoder->decodeDouble(value))
>-                return false;
>-            filter = BasicComponentTransferFilterOperation::create(value, type);
>-            break;
>-        }
>-        case FilterOperation::BLUR: {
>-            Length length;
>-            if (!ArgumentCoder<Length>::decode(decoder, length))
>-                return false;
>-            filter = BlurFilterOperation::create(length, type);
>-            break;
>-        }
>-        case FilterOperation::DROP_SHADOW: {
>-            IntPoint location;
>-            int32_t stdDeviation;
>-            Color color;
>-            if (!ArgumentCoder<IntPoint>::decode(decoder, location))
>-                return false;
>-            if (!decoder->decodeInt32(stdDeviation))
>-                return false;
>-            if (!ArgumentCoder<Color>::decode(decoder, color))
>-                return false;
>-            filter = DropShadowFilterOperation::create(location, stdDeviation, color, type);
>-            break;
>-        }
>-        default:
>-            break;
>-        }
>-
>-        if (filter)
>-            operations.append(filter);
>-    }
>-
>-    return true;
>-}
>-#endif
>-
>-#if USE(GRAPHICS_SURFACE)
>-void ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode(ArgumentEncoder* encoder, const WebCore::GraphicsSurfaceToken& token)
>-{
>-#if OS(DARWIN)
>-    encoder->encodeUInt32(token.frontBufferHandle);
>-    encoder->encodeUInt32(token.backBufferHandle);
>-#endif
>-#if OS(LINUX)
>-    encoder->encodeUInt32(token.frontBufferHandle);
>-#endif
>-}
>-
>-bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(ArgumentDecoder* decoder, WebCore::GraphicsSurfaceToken& token)
>-{
>-#if OS(DARWIN)
>-    if (!decoder->decodeUInt32(token.frontBufferHandle))
>-        return false;
>-    if (!decoder->decodeUInt32(token.backBufferHandle))
>-        return false;
>-#endif
>-#if OS(LINUX)
>-    if (!decoder->decodeUInt32(token.frontBufferHandle))
>-        return false;
>-#endif
>-    return true;
>-}
>-
>-#endif
>-
>-#endif
>-
> void ArgumentCoder<WebCore::UserStyleSheet>::encode(ArgumentEncoder* encoder, const WebCore::UserStyleSheet& userStyleSheet)
> {
>     encoder->encode(userStyleSheet.source());
>diff --git a/Source/WebKit2/Shared/WebCoreArgumentCoders.h b/Source/WebKit2/Shared/WebCoreArgumentCoders.h
>index 581058cab7cfd67aed28d69b0a0193344ad019ad..6850d6bc7720963d7287dd4ca7f050177e95b07e 100644
>--- a/Source/WebKit2/Shared/WebCoreArgumentCoders.h
>+++ b/Source/WebKit2/Shared/WebCoreArgumentCoders.h
>@@ -69,24 +69,6 @@ namespace WebCore {
> }
> #endif
> 
>-#if USE(COORDINATED_GRAPHICS)
>-namespace WebCore {
>-    class FloatPoint3D;
>-    class TransformationMatrix;
>-    struct Length;
>-
>-#if USE(GRAPHICS_SURFACE)
>-    struct GraphicsSurfaceToken;
>-#endif
>-}
>-
>-#if ENABLE(CSS_FILTERS)
>-namespace WebCore {
>-    class FilterOperations;
>-}
>-#endif
>-#endif
>-
> namespace CoreIPC {
> 
> template<> struct ArgumentCoder<WebCore::AffineTransform> {
>@@ -260,37 +242,6 @@ template<> struct ArgumentCoder<WebCore::KURL> {
>     static bool decode(ArgumentDecoder*, WebCore::KURL&);
> };
> 
>-#if USE(COORDINATED_GRAPHICS)
>-template<> struct ArgumentCoder<WebCore::FloatPoint3D> {
>-    static void encode(ArgumentEncoder*, const WebCore::FloatPoint3D&);
>-    static bool decode(ArgumentDecoder*, WebCore::FloatPoint3D&);
>-};
>-
>-template<> struct ArgumentCoder<WebCore::Length> {
>-    static void encode(ArgumentEncoder*, const WebCore::Length&);
>-    static bool decode(ArgumentDecoder*, WebCore::Length&);
>-};
>-
>-template<> struct ArgumentCoder<WebCore::TransformationMatrix> {
>-    static void encode(ArgumentEncoder*, const WebCore::TransformationMatrix&);
>-    static bool decode(ArgumentDecoder*, WebCore::TransformationMatrix&);
>-};
>-
>-#if ENABLE(CSS_FILTERS)
>-template<> struct ArgumentCoder<WebCore::FilterOperations> {
>-    static void encode(ArgumentEncoder*, const WebCore::FilterOperations&);
>-    static bool decode(ArgumentDecoder*, WebCore::FilterOperations&);
>-};
>-#endif
>-
>-#if USE(GRAPHICS_SURFACE)
>-template<> struct ArgumentCoder<WebCore::GraphicsSurfaceToken> {
>-    static void encode(ArgumentEncoder*, const WebCore::GraphicsSurfaceToken&);
>-    static bool decode(ArgumentDecoder*, WebCore::GraphicsSurfaceToken&);
>-};
>-#endif
>-#endif
>-
> template<> struct ArgumentCoder<WebCore::UserStyleSheet> {
>     static void encode(ArgumentEncoder*, const WebCore::UserStyleSheet&);
>     static bool decode(ArgumentDecoder*, WebCore::UserStyleSheet&);
>diff --git a/Source/WebKit2/Target.pri b/Source/WebKit2/Target.pri
>index 4f3930753cafc18c0007ad7ca1bf488ee614b936..2eedf803c21197b1749622d4993b9a7eaa88da80 100644
>--- a/Source/WebKit2/Target.pri
>+++ b/Source/WebKit2/Target.pri
>@@ -130,6 +130,8 @@ HEADERS += \
>     Shared/WebURLRequest.h \
>     Shared/WebURLResponse.h \
>     Shared/WebUserContentURLPattern.h \
>+    Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h \
>+    Shared/CoordinatedGraphics/WebCustomFilterProgram.h \
>     Shared/Plugins/Netscape/NetscapePluginModule.h \
>     Shared/Plugins/NPRemoteObjectMap.h \
>     Shared/Plugins/NPIdentifierData.h \
>@@ -486,6 +488,7 @@ SOURCES += \
>     Shared/WebURLRequest.cpp \
>     Shared/WebURLResponse.cpp \
>     Shared/WebWheelEvent.cpp \
>+    Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp \
>     Shared/qt/ArgumentCodersQt.cpp \
>     Shared/qt/LayerTreeContextQt.cpp \
>     Shared/qt/ShareableBitmapQt.cpp \
>diff --git a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h
>index b1ef401a445025b22c67fb6d50e704f85cc89d6c..1a2abbdf19203c5b8d23249ed26ee33d85db3a5a 100644
>--- a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h
>+++ b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h
>@@ -23,6 +23,7 @@
> #if USE(COORDINATED_GRAPHICS)
> 
> #include "BackingStore.h"
>+#include "CoordinatedGraphicsArgumentCoders.h"
> #include "DrawingAreaProxy.h"
> #include "Region.h"
> #include "SurfaceUpdateInfo.h"
>diff --git a/Source/WebKit2/WebKit2.pri b/Source/WebKit2/WebKit2.pri
>index 536b779babbfee78a8ede669e7bdab7a8c8c5866..80cb2fb8e795a280c4979eb2f9afb34a35f94fc8 100644
>--- a/Source/WebKit2/WebKit2.pri
>+++ b/Source/WebKit2/WebKit2.pri
>@@ -16,6 +16,7 @@ INCLUDEPATH += \
>     $$SOURCE_DIR/Platform/qt \
>     $$SOURCE_DIR/Shared \
>     $$SOURCE_DIR/Shared/API/c \
>+    $$SOURCE_DIR/Shared/CoordinatedGraphics \
>     $$SOURCE_DIR/Shared/CoreIPCSupport \
>     $$SOURCE_DIR/Shared/Plugins \
>     $$SOURCE_DIR/Shared/Plugins/Netscape \
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp
>index a19715e7ea8b5d04bd6796072ce08616ef5aa5de..aaa1c38d5776a51ad0f339470f12f61622428c24 100644
>--- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp
>@@ -29,6 +29,7 @@
> #if USE(COORDINATED_GRAPHICS)
> #include "LayerTreeCoordinator.h"
> 
>+#include "CoordinatedGraphicsArgumentCoders.h"
> #include "CoordinatedGraphicsLayer.h"
> #include "DrawingAreaImpl.h"
> #include "GraphicsContext.h"

Actions: View | Formatted Diff | Diff

Attachments on bug 98733: 167718 | 167722 | 167854 | 167967 | 168539 | 168595 | 168619 | 168625 | 168668 | 168670 | 169382