[Qt] [WK2] Fix build after r141619
authorcaio.oliveira@openbossa.org <caio.oliveira@openbossa.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 1 Feb 2013 21:08:31 +0000 (21:08 +0000)
committercaio.oliveira@openbossa.org <caio.oliveira@openbossa.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 1 Feb 2013 21:08:31 +0000 (21:08 +0000)
https://bugs.webkit.org/show_bug.cgi?id=108680

Reviewed by Benjamin Poulain.

Take a reference instead of a pointer for decoding functions.

* Platform/unix/SharedMemoryUnix.cpp:
(WebKit::SharedMemory::Handle::decode):
* Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp:
(CoreIPC::::decode):
(CoreIPC::decodeTimingFunction):
* Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h:
* Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp:
(WebKit::WebCoordinatedSurface::Handle::decode):
* Shared/CoordinatedGraphics/WebCoordinatedSurface.h:
(Handle):
* Shared/qt/ArgumentCodersQt.cpp:
(CoreIPC::::decode):
* Shared/qt/ArgumentCodersQt.h:
(CoreIPC):
* Shared/qt/LayerTreeContextQt.cpp:
(WebKit::LayerTreeContext::decode):
* Shared/qt/PlatformCertificateInfo.h:
(WebKit::PlatformCertificateInfo::decode):
* Shared/qt/QtNetworkReplyData.cpp:
(WebKit::QtNetworkReplyData::decode):
* Shared/qt/QtNetworkReplyData.h:
(QtNetworkReplyData):
* Shared/qt/QtNetworkRequestData.cpp:
(WebKit::QtNetworkRequestData::decode):
* Shared/qt/QtNetworkRequestData.h:
(QtNetworkRequestData):
* Shared/qt/WebCoreArgumentCodersQt.cpp:
(CoreIPC::::decodePlatformData):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@141632 268f45cc-cd09-0410-ab3c-d52691b4dbfc

15 files changed:
Source/WebKit2/ChangeLog
Source/WebKit2/Platform/unix/SharedMemoryUnix.cpp
Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp
Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h
Source/WebKit2/Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp
Source/WebKit2/Shared/CoordinatedGraphics/WebCoordinatedSurface.h
Source/WebKit2/Shared/qt/ArgumentCodersQt.cpp
Source/WebKit2/Shared/qt/ArgumentCodersQt.h
Source/WebKit2/Shared/qt/LayerTreeContextQt.cpp
Source/WebKit2/Shared/qt/PlatformCertificateInfo.h
Source/WebKit2/Shared/qt/QtNetworkReplyData.cpp
Source/WebKit2/Shared/qt/QtNetworkReplyData.h
Source/WebKit2/Shared/qt/QtNetworkRequestData.cpp
Source/WebKit2/Shared/qt/QtNetworkRequestData.h
Source/WebKit2/Shared/qt/WebCoreArgumentCodersQt.cpp

index f9754d7..2c32557 100644 (file)
@@ -1,3 +1,41 @@
+2013-02-01  Caio Marcelo de Oliveira Filho  <caio.oliveira@openbossa.org>
+
+        [Qt] [WK2] Fix build after r141619
+        https://bugs.webkit.org/show_bug.cgi?id=108680
+
+        Reviewed by Benjamin Poulain.
+
+        Take a reference instead of a pointer for decoding functions.
+
+        * Platform/unix/SharedMemoryUnix.cpp:
+        (WebKit::SharedMemory::Handle::decode):
+        * Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp:
+        (CoreIPC::::decode):
+        (CoreIPC::decodeTimingFunction):
+        * Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h:
+        * Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp:
+        (WebKit::WebCoordinatedSurface::Handle::decode):
+        * Shared/CoordinatedGraphics/WebCoordinatedSurface.h:
+        (Handle):
+        * Shared/qt/ArgumentCodersQt.cpp:
+        (CoreIPC::::decode):
+        * Shared/qt/ArgumentCodersQt.h:
+        (CoreIPC):
+        * Shared/qt/LayerTreeContextQt.cpp:
+        (WebKit::LayerTreeContext::decode):
+        * Shared/qt/PlatformCertificateInfo.h:
+        (WebKit::PlatformCertificateInfo::decode):
+        * Shared/qt/QtNetworkReplyData.cpp:
+        (WebKit::QtNetworkReplyData::decode):
+        * Shared/qt/QtNetworkReplyData.h:
+        (QtNetworkReplyData):
+        * Shared/qt/QtNetworkRequestData.cpp:
+        (WebKit::QtNetworkRequestData::decode):
+        * Shared/qt/QtNetworkRequestData.h:
+        (QtNetworkRequestData):
+        * Shared/qt/WebCoreArgumentCodersQt.cpp:
+        (CoreIPC::::decodePlatformData):
+
 2013-02-01  Anders Carlsson  <andersca@apple.com>
 
         Message decoding functions should take a MessageDecoder reference
index f565b76..f763819 100644 (file)
@@ -68,13 +68,13 @@ void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder.encode(releaseToAttachment());
 }
 
-bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)
+bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
 {
     ASSERT_ARG(handle, !handle.m_size);
     ASSERT_ARG(handle, handle.isNull());
 
     CoreIPC::Attachment attachment;
-    if (!decoder->decode(attachment))
+    if (!decoder.decode(attachment))
         return false;
 
     handle.adoptFromAttachment(attachment.releaseFileDescriptor(), attachment.size());
index c3371d2..5a06d11 100644 (file)
@@ -84,7 +84,7 @@ void ArgumentCoder<FloatPoint3D>::encode(ArgumentEncoder& encoder, const FloatPo
     SimpleArgumentCoder<FloatPoint3D>::encode(encoder, floatPoint3D);
 }
 
-bool ArgumentCoder<FloatPoint3D>::decode(ArgumentDecoder* decoder, FloatPoint3D& floatPoint3D)
+bool ArgumentCoder<FloatPoint3D>::decode(ArgumentDecoder& decoder, FloatPoint3D& floatPoint3D)
 {
     return SimpleArgumentCoder<FloatPoint3D>::decode(decoder, floatPoint3D);
 }
@@ -94,7 +94,7 @@ void ArgumentCoder<Length>::encode(ArgumentEncoder& encoder, const Length& lengt
     SimpleArgumentCoder<Length>::encode(encoder, length);
 }
 
-bool ArgumentCoder<Length>::decode(ArgumentDecoder* decoder, Length& length)
+bool ArgumentCoder<Length>::decode(ArgumentDecoder& decoder, Length& length)
 {
     return SimpleArgumentCoder<Length>::decode(decoder, length);
 }
@@ -104,7 +104,7 @@ void ArgumentCoder<TransformationMatrix>::encode(ArgumentEncoder& encoder, const
     SimpleArgumentCoder<TransformationMatrix>::encode(encoder, transformationMatrix);
 }
 
-bool ArgumentCoder<TransformationMatrix>::decode(ArgumentDecoder* decoder, TransformationMatrix& transformationMatrix)
+bool ArgumentCoder<TransformationMatrix>::decode(ArgumentDecoder& decoder, TransformationMatrix& transformationMatrix)
 {
     return SimpleArgumentCoder<TransformationMatrix>::decode(decoder, transformationMatrix);
 }
@@ -199,10 +199,10 @@ void ArgumentCoder<WebCore::FilterOperations>::encode(ArgumentEncoder& encoder,
     }
 }
 
-bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder, WebCore::FilterOperations& filters)
+bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder& decoder, WebCore::FilterOperations& filters)
 {
     uint32_t size;
-    if (!decoder->decode(size))
+    if (!decoder.decode(size))
         return false;
 
     Vector<RefPtr<FilterOperation> >& operations = filters.operations();
@@ -210,7 +210,7 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder,
     for (size_t i = 0; i < size; ++i) {
         FilterOperation::OperationType type;
         RefPtr<FilterOperation> filter;
-        if (!decoder->decodeEnum(type))
+        if (!decoder.decodeEnum(type))
             return false;
 
         switch (type) {
@@ -219,7 +219,7 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder,
         case FilterOperation::SATURATE:
         case FilterOperation::HUE_ROTATE: {
             double value;
-            if (!decoder->decode(value))
+            if (!decoder.decode(value))
                 return false;
             filter = BasicColorMatrixFilterOperation::create(value, type);
             break;
@@ -229,7 +229,7 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder,
         case FilterOperation::CONTRAST:
         case FilterOperation::OPACITY: {
             double value;
-            if (!decoder->decode(value))
+            if (!decoder.decode(value))
                 return false;
             filter = BasicComponentTransferFilterOperation::create(value, type);
             break;
@@ -247,7 +247,7 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder,
             Color color;
             if (!ArgumentCoder<IntPoint>::decode(decoder, location))
                 return false;
-            if (!decoder->decode(stdDeviation))
+            if (!decoder.decode(stdDeviation))
                 return false;
             if (!ArgumentCoder<Color>::decode(decoder, color))
                 return false;
@@ -263,34 +263,34 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder,
             // FIXME: CustomFilterOperation should not need the meshType.
             // https://bugs.webkit.org/show_bug.cgi?id=102529
             CustomFilterMeshType meshType;
-            if (!decoder->decodeEnum(meshType))
+            if (!decoder.decodeEnum(meshType))
                 return false;
             int programID = 0;
-            if (!decoder->decode(programID))
+            if (!decoder.decode(programID))
                 return false;
 
             uint32_t parametersSize;
-            if (!decoder->decode(parametersSize))
+            if (!decoder.decode(parametersSize))
                 return false;
 
             CustomFilterParameterList parameters(parametersSize);
             for (size_t i = 0; i < parametersSize; ++i) {
                 String name;
                 CustomFilterParameter::ParameterType parameterType;
-                if (!decoder->decode(name))
+                if (!decoder.decode(name))
                     return false;
-                if (!decoder->decodeEnum(parameterType))
+                if (!decoder.decodeEnum(parameterType))
                     return false;
 
                 switch (parameterType) {
                 case CustomFilterParameter::ARRAY: {
                     RefPtr<CustomFilterArrayParameter> arrayParameter = CustomFilterArrayParameter::create(name);
                     uint32_t arrayParameterSize;
-                    if (!decoder->decode(arrayParameterSize))
+                    if (!decoder.decode(arrayParameterSize))
                         return false;
                     double arrayParameterValue;
                     for (size_t j = 0; j < arrayParameterSize; ++j) {
-                        if (!decoder->decode(arrayParameterValue))
+                        if (!decoder.decode(arrayParameterValue))
                             return false;
                         arrayParameter->addValue(arrayParameterValue);
                     }
@@ -300,11 +300,11 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder,
                 case CustomFilterParameter::NUMBER: {
                     RefPtr<CustomFilterNumberParameter> numberParameter = CustomFilterNumberParameter::create(name);
                     uint32_t numberParameterSize;
-                    if (!decoder->decode(numberParameterSize))
+                    if (!decoder.decode(numberParameterSize))
                         return false;
                     double numberParameterValue;
                     for (size_t j = 0; j < numberParameterSize; ++j) {
-                        if (!decoder->decode(numberParameterValue))
+                        if (!decoder.decode(numberParameterValue))
                             return false;
                         numberParameter->addValue(numberParameterValue);
                     }
@@ -325,9 +325,9 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder,
 
             unsigned meshRows;
             unsigned meshColumns;
-            if (!decoder->decode(meshRows))
+            if (!decoder.decode(meshRows))
                 return false;
-            if (!decoder->decode(meshColumns))
+            if (!decoder.decode(meshColumns))
                 return false;
 
             // At this point the Shaders are already validated, so we just use WebCustomFilterOperation for transportation.
@@ -359,24 +359,24 @@ void ArgumentCoder<WebCore::CustomFilterProgramInfo>::encode(ArgumentEncoder& en
     encoder.encodeEnum(mixSettings.compositeOperator);
 }
 
-bool ArgumentCoder<WebCore::CustomFilterProgramInfo>::decode(ArgumentDecoder* decoder, CustomFilterProgramInfo& programInfo)
+bool ArgumentCoder<WebCore::CustomFilterProgramInfo>::decode(ArgumentDecoder& decoder, CustomFilterProgramInfo& programInfo)
 {
     String vertexShaderString;
     String fragmentShaderString;
     CustomFilterProgramType programType;
     CustomFilterMeshType meshType;
     CustomFilterProgramMixSettings mixSettings;
-    if (!decoder->decode(vertexShaderString))
+    if (!decoder.decode(vertexShaderString))
         return false;
-    if (!decoder->decode(fragmentShaderString))
+    if (!decoder.decode(fragmentShaderString))
         return false;
-    if (!decoder->decodeEnum(programType))
+    if (!decoder.decodeEnum(programType))
         return false;
-    if (!decoder->decodeEnum(meshType))
+    if (!decoder.decodeEnum(meshType))
         return false;
-    if (!decoder->decodeEnum(mixSettings.blendMode))
+    if (!decoder.decodeEnum(mixSettings.blendMode))
         return false;
-    if (!decoder->decodeEnum(mixSettings.compositeOperator))
+    if (!decoder.decodeEnum(mixSettings.compositeOperator))
         return false;
     programInfo = CustomFilterProgramInfo(vertexShaderString, fragmentShaderString, programType, mixSettings, meshType);
     return true;
@@ -442,15 +442,15 @@ void ArgumentCoder<TransformOperations>::encode(ArgumentEncoder& encoder, const
     }
 }
 
-bool ArgumentCoder<TransformOperations>::decode(ArgumentDecoder* decoder, TransformOperations& transformOperations)
+bool ArgumentCoder<TransformOperations>::decode(ArgumentDecoder& decoder, TransformOperations& transformOperations)
 {
     uint32_t operationsSize;
-    if (!decoder->decode(operationsSize))
+    if (!decoder.decode(operationsSize))
         return false;
 
     for (size_t i = 0; i < operationsSize; ++i) {
         TransformOperation::OperationType operationType;
-        if (!decoder->decodeEnum(operationType))
+        if (!decoder.decodeEnum(operationType))
             return false;
 
         switch (operationType) {
@@ -460,11 +460,11 @@ bool ArgumentCoder<TransformOperations>::decode(ArgumentDecoder* decoder, Transf
         case TransformOperation::SCALE_Z:
         case TransformOperation::SCALE_3D: {
             double x, y, z;
-            if (!decoder->decode(x))
+            if (!decoder.decode(x))
                 return false;
-            if (!decoder->decode(y))
+            if (!decoder.decode(y))
                 return false;
-            if (!decoder->decode(z))
+            if (!decoder.decode(z))
                 return false;
             transformOperations.operations().append(ScaleTransformOperation::create(x, y, z, operationType));
             break;
@@ -489,13 +489,13 @@ bool ArgumentCoder<TransformOperations>::decode(ArgumentDecoder* decoder, Transf
         case TransformOperation::ROTATE_Y:
         case TransformOperation::ROTATE_3D: {
             double x, y, z, angle;
-            if (!decoder->decode(x))
+            if (!decoder.decode(x))
                 return false;
-            if (!decoder->decode(y))
+            if (!decoder.decode(y))
                 return false;
-            if (!decoder->decode(z))
+            if (!decoder.decode(z))
                 return false;
-            if (!decoder->decode(angle))
+            if (!decoder.decode(angle))
                 return false;
             transformOperations.operations().append(RotateTransformOperation::create(x, y, z, angle, operationType));
             break;
@@ -504,9 +504,9 @@ bool ArgumentCoder<TransformOperations>::decode(ArgumentDecoder* decoder, Transf
         case TransformOperation::SKEW_Y:
         case TransformOperation::SKEW: {
             double angleX, angleY;
-            if (!decoder->decode(angleX))
+            if (!decoder.decode(angleX))
                 return false;
-            if (!decoder->decode(angleY))
+            if (!decoder.decode(angleY))
                 return false;
             transformOperations.operations().append(SkewTransformOperation::create(angleX, angleY, operationType));
             break;
@@ -576,10 +576,10 @@ static void encodeTimingFunction(ArgumentEncoder& encoder, const TimingFunction*
     }
 }
 
-bool decodeTimingFunction(ArgumentDecoder* decoder, RefPtr<TimingFunction>& timingFunction)
+bool decodeTimingFunction(ArgumentDecoder& decoder, RefPtr<TimingFunction>& timingFunction)
 {
     TimingFunction::TimingFunctionType type;
-    if (!decoder->decodeEnum(type))
+    if (!decoder.decodeEnum(type))
         return false;
 
     if (type == TimingFunction::TimingFunctionType(-1))
@@ -592,19 +592,19 @@ bool decodeTimingFunction(ArgumentDecoder* decoder, RefPtr<TimingFunction>& timi
     case TimingFunction::CubicBezierFunction: {
         double x1, y1, x2, y2;
         CubicBezierTimingFunction::TimingFunctionPreset bezierPreset;
-        if (!decoder->decodeEnum(bezierPreset))
+        if (!decoder.decodeEnum(bezierPreset))
             return false;
         if (bezierPreset != CubicBezierTimingFunction::Custom) {
             timingFunction = CubicBezierTimingFunction::create(bezierPreset);
             return true;
         }
-        if (!decoder->decode(x1))
+        if (!decoder.decode(x1))
             return false;
-        if (!decoder->decode(y1))
+        if (!decoder.decode(y1))
             return false;
-        if (!decoder->decode(x2))
+        if (!decoder.decode(x2))
             return false;
-        if (!decoder->decode(y2))
+        if (!decoder.decode(y2))
             return false;
 
         timingFunction = CubicBezierTimingFunction::create(x1, y1, x2, y2);
@@ -613,9 +613,9 @@ bool decodeTimingFunction(ArgumentDecoder* decoder, RefPtr<TimingFunction>& timi
     case TimingFunction::StepsFunction: {
         uint32_t numberOfSteps;
         bool stepAtStart;
-        if (!decoder->decode(numberOfSteps))
+        if (!decoder.decode(numberOfSteps))
             return false;
-        if (!decoder->decode(stepAtStart))
+        if (!decoder.decode(stepAtStart))
             return false;
 
         timingFunction = StepsTimingFunction::create(numberOfSteps, stepAtStart);
@@ -667,7 +667,7 @@ void ArgumentCoder<GraphicsLayerAnimation>::encode(ArgumentEncoder& encoder, con
     }
 }
 
-bool ArgumentCoder<GraphicsLayerAnimation>::decode(ArgumentDecoder* decoder, GraphicsLayerAnimation& animation)
+bool ArgumentCoder<GraphicsLayerAnimation>::decode(ArgumentDecoder& decoder, GraphicsLayerAnimation& animation)
 {
     String name;
     IntSize boxSize;
@@ -683,25 +683,25 @@ bool ArgumentCoder<GraphicsLayerAnimation>::decode(ArgumentDecoder* decoder, Gra
     RefPtr<TimingFunction> timingFunction;
     RefPtr<Animation> animationObject;
 
-    if (!decoder->decode(name))
+    if (!decoder.decode(name))
         return false;
-    if (!decoder->decode(boxSize))
+    if (!decoder.decode(boxSize))
         return false;
-    if (!decoder->decodeEnum(state))
+    if (!decoder.decodeEnum(state))
         return false;
-    if (!decoder->decode(startTime))
+    if (!decoder.decode(startTime))
         return false;
-    if (!decoder->decode(pauseTime))
+    if (!decoder.decode(pauseTime))
         return false;
-    if (!decoder->decode(listsMatch))
+    if (!decoder.decode(listsMatch))
         return false;
-    if (!decoder->decodeEnum(direction))
+    if (!decoder.decodeEnum(direction))
         return false;
-    if (!decoder->decode(fillMode))
+    if (!decoder.decode(fillMode))
         return false;
-    if (!decoder->decode(duration))
+    if (!decoder.decode(duration))
         return false;
-    if (!decoder->decode(iterationCount))
+    if (!decoder.decode(iterationCount))
         return false;
     if (!decodeTimingFunction(decoder, timingFunction))
         return false;
@@ -715,16 +715,16 @@ bool ArgumentCoder<GraphicsLayerAnimation>::decode(ArgumentDecoder* decoder, Gra
         animationObject->setTimingFunction(timingFunction);
 
     AnimatedPropertyID property;
-    if (!decoder->decodeEnum(property))
+    if (!decoder.decodeEnum(property))
         return false;
     KeyframeValueList keyframes(property);
     unsigned keyframesSize;
-    if (!decoder->decode(keyframesSize))
+    if (!decoder.decode(keyframesSize))
         return false;
     for (unsigned i = 0; i < keyframesSize; ++i) {
         float keyTime;
         RefPtr<TimingFunction> timingFunction;
-        if (!decoder->decode(keyTime))
+        if (!decoder.decode(keyTime))
             return false;
         if (!decodeTimingFunction(decoder, timingFunction))
             return false;
@@ -732,14 +732,14 @@ bool ArgumentCoder<GraphicsLayerAnimation>::decode(ArgumentDecoder* decoder, Gra
         switch (property) {
         case AnimatedPropertyOpacity: {
             float value;
-            if (!decoder->decode(value))
+            if (!decoder.decode(value))
                 return false;
             keyframes.insert(new FloatAnimationValue(keyTime, value, timingFunction));
             break;
         }
         case AnimatedPropertyWebkitTransform: {
             TransformOperations transform;
-            if (!decoder->decode(transform))
+            if (!decoder.decode(transform))
                 return false;
             keyframes.insert(new TransformAnimationValue(keyTime, &transform, timingFunction));
             break;
@@ -747,7 +747,7 @@ bool ArgumentCoder<GraphicsLayerAnimation>::decode(ArgumentDecoder* decoder, Gra
 #if ENABLE(CSS_FILTERS)
         case AnimatedPropertyWebkitFilter: {
             FilterOperations filter;
-            if (!decoder->decode(filter))
+            if (!decoder.decode(filter))
                 return false;
             keyframes.insert(new FilterAnimationValue(keyTime, &filter, timingFunction));
             break;
@@ -769,9 +769,9 @@ void ArgumentCoder<GraphicsLayerAnimations>::encode(ArgumentEncoder& encoder, co
     encoder << animations.animations();
 }
 
-bool ArgumentCoder<GraphicsLayerAnimations>::decode(ArgumentDecoder* decoder, GraphicsLayerAnimations& animations)
+bool ArgumentCoder<GraphicsLayerAnimations>::decode(ArgumentDecoder& decoder, GraphicsLayerAnimations& animations)
 {
-    return decoder->decode(animations.animations());
+    return decoder.decode(animations.animations());
 }
 
 #if USE(GRAPHICS_SURFACE)
@@ -788,27 +788,27 @@ void ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode(ArgumentEncoder& encod
 #endif
 }
 
-bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(ArgumentDecoder* decoder, WebCore::GraphicsSurfaceToken& token)
+bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(ArgumentDecoder& decoder, WebCore::GraphicsSurfaceToken& token)
 {
 #if OS(WINDOWS)
     uint64_t frontBufferHandle;
-    if (!decoder->decode(frontBufferHandle))
+    if (!decoder.decode(frontBufferHandle))
         return false;
     token.frontBufferHandle = reinterpret_cast<GraphicsSurfaceToken::BufferHandle>(frontBufferHandle);
     uint64_t backBufferHandle;
-    if (!decoder->decode(backBufferHandle))
+    if (!decoder.decode(backBufferHandle))
         return false;
     token.backBufferHandle = reinterpret_cast<GraphicsSurfaceToken::BufferHandle>(backBufferHandle);
 #elif OS(DARWIN)
     Attachment frontAttachment, backAttachment;
-    if (!decoder->decode(frontAttachment))
+    if (!decoder.decode(frontAttachment))
         return false;
-    if (!decoder->decode(backAttachment))
+    if (!decoder.decode(backAttachment))
         return false;
 
     token = GraphicsSurfaceToken(frontAttachment.port(), backAttachment.port());
 #elif OS(LINUX)
-    if (!decoder->decode(token.frontBufferHandle))
+    if (!decoder.decode(token.frontBufferHandle))
         return false;
 #endif
     return true;
@@ -820,7 +820,7 @@ void ArgumentCoder<CoordinatedLayerInfo>::encode(ArgumentEncoder& encoder, const
     SimpleArgumentCoder<CoordinatedLayerInfo>::encode(encoder, coordinatedLayerInfo);
 }
 
-bool ArgumentCoder<CoordinatedLayerInfo>::decode(ArgumentDecoder* decoder, CoordinatedLayerInfo& coordinatedLayerInfo)
+bool ArgumentCoder<CoordinatedLayerInfo>::decode(ArgumentDecoder& decoder, CoordinatedLayerInfo& coordinatedLayerInfo)
 {
     return SimpleArgumentCoder<CoordinatedLayerInfo>::decode(decoder, coordinatedLayerInfo);
 }
@@ -830,7 +830,7 @@ void ArgumentCoder<SurfaceUpdateInfo>::encode(ArgumentEncoder& encoder, const Su
     SimpleArgumentCoder<SurfaceUpdateInfo>::encode(encoder, surfaceUpdateInfo);
 }
 
-bool ArgumentCoder<SurfaceUpdateInfo>::decode(ArgumentDecoder* decoder, SurfaceUpdateInfo& surfaceUpdateInfo)
+bool ArgumentCoder<SurfaceUpdateInfo>::decode(ArgumentDecoder& decoder, SurfaceUpdateInfo& surfaceUpdateInfo)
 {
     return SimpleArgumentCoder<SurfaceUpdateInfo>::decode(decoder, surfaceUpdateInfo);
 }
index d6efff5..8e7deef 100644 (file)
@@ -58,63 +58,63 @@ namespace CoreIPC {
 
 template<> struct ArgumentCoder<WebCore::FloatPoint3D> {
     static void encode(ArgumentEncoder&, const WebCore::FloatPoint3D&);
-    static bool decode(ArgumentDecoder*, 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&);
+    static bool decode(ArgumentDecoder&, WebCore::Length&);
 };
 
 template<> struct ArgumentCoder<WebCore::TransformationMatrix> {
     static void encode(ArgumentEncoder&, const WebCore::TransformationMatrix&);
-    static bool decode(ArgumentDecoder*, 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&);
+    static bool decode(ArgumentDecoder&, WebCore::FilterOperations&);
 };
 #endif
 
 #if ENABLE(CSS_SHADERS)
 template<> struct ArgumentCoder<WebCore::CustomFilterProgramInfo> {
     static void encode(ArgumentEncoder&, const WebCore::CustomFilterProgramInfo&);
-    static bool decode(ArgumentDecoder*, WebCore::CustomFilterProgramInfo&);
+    static bool decode(ArgumentDecoder&, WebCore::CustomFilterProgramInfo&);
 };
 #endif
 
 template<> struct ArgumentCoder<WebCore::TransformOperations> {
     static void encode(ArgumentEncoder&, const WebCore::TransformOperations&);
-    static bool decode(ArgumentDecoder*, WebCore::TransformOperations&);
+    static bool decode(ArgumentDecoder&, WebCore::TransformOperations&);
 };
 
 template<> struct ArgumentCoder<WebCore::GraphicsLayerAnimations> {
     static void encode(ArgumentEncoder&, const WebCore::GraphicsLayerAnimations&);
-    static bool decode(ArgumentDecoder*, WebCore::GraphicsLayerAnimations&);
+    static bool decode(ArgumentDecoder&, WebCore::GraphicsLayerAnimations&);
 };
 
 template<> struct ArgumentCoder<WebCore::GraphicsLayerAnimation> {
     static void encode(ArgumentEncoder&, const WebCore::GraphicsLayerAnimation&);
-    static bool decode(ArgumentDecoder*, WebCore::GraphicsLayerAnimation&);
+    static bool decode(ArgumentDecoder&, WebCore::GraphicsLayerAnimation&);
 };
 
 #if USE(GRAPHICS_SURFACE)
 template<> struct ArgumentCoder<WebCore::GraphicsSurfaceToken> {
     static void encode(ArgumentEncoder&, const WebCore::GraphicsSurfaceToken&);
-    static bool decode(ArgumentDecoder*, WebCore::GraphicsSurfaceToken&);
+    static bool decode(ArgumentDecoder&, WebCore::GraphicsSurfaceToken&);
 };
 #endif
 
 template<> struct ArgumentCoder<WebCore::CoordinatedLayerInfo> {
     static void encode(ArgumentEncoder&, const WebCore::CoordinatedLayerInfo&);
-    static bool decode(ArgumentDecoder*, WebCore::CoordinatedLayerInfo&);
+    static bool decode(ArgumentDecoder&, WebCore::CoordinatedLayerInfo&);
 };
 
 template<> struct ArgumentCoder<WebCore::SurfaceUpdateInfo> {
     static void encode(ArgumentEncoder&, const WebCore::SurfaceUpdateInfo&);
-    static bool decode(ArgumentDecoder*, WebCore::SurfaceUpdateInfo&);
+    static bool decode(ArgumentDecoder&, WebCore::SurfaceUpdateInfo&);
 };
 
 } // namespace CoreIPC
index b5a3845..52b7f6d 100644 (file)
@@ -50,19 +50,19 @@ void WebCoordinatedSurface::Handle::encode(CoreIPC::ArgumentEncoder& encoder) co
     encoder << m_bitmapHandle;
 }
 
-bool WebCoordinatedSurface::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)
+bool WebCoordinatedSurface::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
 {
-    if (!decoder->decode(handle.m_size))
+    if (!decoder.decode(handle.m_size))
         return false;
-    if (!decoder->decode(handle.m_flags))
+    if (!decoder.decode(handle.m_flags))
         return false;
 #if USE(GRAPHICS_SURFACE)
-    if (!decoder->decode(handle.m_graphicsSurfaceToken))
+    if (!decoder.decode(handle.m_graphicsSurfaceToken))
         return false;
     if (handle.m_graphicsSurfaceToken.isValid())
         return true;
 #endif
-    if (!decoder->decode(handle.m_bitmapHandle))
+    if (!decoder.decode(handle.m_bitmapHandle))
         return false;
 
     return true;
index 14a7c00..5386a91 100644 (file)
@@ -44,7 +44,7 @@ public:
         Handle();
 
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, Handle&);
+        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
 
 #if USE(GRAPHICS_SURFACE)
         WebCore::GraphicsSurfaceToken graphicsSurfaceToken() const { return m_graphicsSurfaceToken; }
index 31c9110..44c855b 100644 (file)
@@ -57,29 +57,29 @@ void ArgumentCoder<WebCore::DragData>::encode(ArgumentEncoder& encoder, const Dr
     encoder << map;
 }
 
-bool ArgumentCoder<WebCore::DragData>::decode(ArgumentDecoder* decoder, DragData& dragData)
+bool ArgumentCoder<WebCore::DragData>::decode(ArgumentDecoder& decoder, DragData& dragData)
 {
     IntPoint clientPosition;
     IntPoint globalPosition;
     uint64_t sourceOperationMask;
     uint64_t flags;
-    if (!decoder->decode(clientPosition))
+    if (!decoder.decode(clientPosition))
         return false;
-    if (!decoder->decode(globalPosition))
+    if (!decoder.decode(globalPosition))
         return false;
-    if (!decoder->decode(sourceOperationMask))
+    if (!decoder.decode(sourceOperationMask))
         return false;
-    if (!decoder->decode(flags))
+    if (!decoder.decode(flags))
         return false;
 
     bool hasPlatformData;
-    if (!decoder->decode(hasPlatformData))
+    if (!decoder.decode(hasPlatformData))
         return false;
 
     QMimeData* mimeData = 0;
     if (hasPlatformData) {
         MIMEDataHashMap map;
-        if (!decoder->decode(map))
+        if (!decoder.decode(map))
             return false;
 
         mimeData = new QMimeData;
index ad85799..8d66e57 100644 (file)
 namespace CoreIPC {
 
 void encode(ArgumentEncoder&, const WebCore::DragData&);
-bool decode(ArgumentDecoder*, WebCore::DragData&);
+bool decode(ArgumentDecoder&, WebCore::DragData&);
 
 template<> struct ArgumentCoder<WebCore::DragData> {
     static void encode(ArgumentEncoder&, const WebCore::DragData&);
-    static bool decode(ArgumentDecoder*, WebCore::DragData&);
+    static bool decode(ArgumentDecoder&, WebCore::DragData&);
 };
 
 }
index 9fc4163..883c9a9 100644 (file)
@@ -45,9 +45,9 @@ void LayerTreeContext::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder.encode(coordinatedLayerID);
 }
 
-bool LayerTreeContext::decode(CoreIPC::ArgumentDecoder* decoder, LayerTreeContext& context)
+bool LayerTreeContext::decode(CoreIPC::ArgumentDecoder& decoder, LayerTreeContext& context)
 {
-    return decoder->decode(context.coordinatedLayerID);
+    return decoder.decode(context.coordinatedLayerID);
 }
 
 bool LayerTreeContext::isEmpty() const
index 9c542a1..c1b9de6 100644 (file)
@@ -46,7 +46,7 @@ public:
     {
     }
 
-    static bool decode(CoreIPC::ArgumentDecoder*, PlatformCertificateInfo&)
+    static bool decode(CoreIPC::ArgumentDecoder&, PlatformCertificateInfo&)
     {
         return true;
     }
index afceadd..5dd5530 100644 (file)
@@ -50,17 +50,17 @@ void QtNetworkReplyData::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder.encode(m_dataHandle);
 }
 
-bool QtNetworkReplyData::decode(CoreIPC::ArgumentDecoder* decoder, QtNetworkReplyData& destination)
+bool QtNetworkReplyData::decode(CoreIPC::ArgumentDecoder& decoder, QtNetworkReplyData& destination)
 {
-    if (!decoder->decode(destination.m_urlString))
+    if (!decoder.decode(destination.m_urlString))
         return false;
-    if (!decoder->decode(destination.m_contentType))
+    if (!decoder.decode(destination.m_contentType))
         return false;
-    if (!decoder->decode(destination.m_contentLength))
+    if (!decoder.decode(destination.m_contentLength))
         return false;
-    if (!decoder->decode(destination.m_replyUuid))
+    if (!decoder.decode(destination.m_replyUuid))
         return false;
-    if (!decoder->decode(destination.m_dataHandle))
+    if (!decoder.decode(destination.m_dataHandle))
         return false;
     return true;
 }
index 02e5a15..6480fb2 100644 (file)
@@ -43,7 +43,7 @@ struct QtNetworkReplyData {
     QtNetworkReplyData();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, QtNetworkReplyData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, QtNetworkReplyData&);
 
     WTF::String m_urlString;
 
index dee903f..f66eb42 100644 (file)
@@ -56,13 +56,13 @@ void QtNetworkRequestData::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder.encode(m_replyUuid);
 }
 
-bool QtNetworkRequestData::decode(CoreIPC::ArgumentDecoder* decoder, QtNetworkRequestData& destination)
+bool QtNetworkRequestData::decode(CoreIPC::ArgumentDecoder& decoder, QtNetworkRequestData& destination)
 {
-    if (!decoder->decode(destination.m_scheme))
+    if (!decoder.decode(destination.m_scheme))
         return false;
-    if (!decoder->decode(destination.m_urlString))
+    if (!decoder.decode(destination.m_urlString))
         return false;
-    if (!decoder->decode(destination.m_replyUuid))
+    if (!decoder.decode(destination.m_replyUuid))
         return false;
     return true;
 }
index 6583945..22a4a8d 100644 (file)
@@ -45,7 +45,7 @@ struct QtNetworkRequestData {
     QtNetworkRequestData();
     QtNetworkRequestData(const QNetworkRequest&, QNetworkReply*);
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, QtNetworkRequestData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, QtNetworkRequestData&);
 
     String m_scheme;
     String m_urlString;
index adf1f21..35bf22f 100644 (file)
@@ -38,7 +38,7 @@ void ArgumentCoder<ResourceRequest>::encodePlatformData(ArgumentEncoder& encoder
 {
 }
 
-bool ArgumentCoder<ResourceRequest>::decodePlatformData(ArgumentDecoder* decoder, ResourceRequest& resourceRequest)
+bool ArgumentCoder<ResourceRequest>::decodePlatformData(ArgumentDecoder& decoder, ResourceRequest& resourceRequest)
 {
     return true;
 }
@@ -48,7 +48,7 @@ void ArgumentCoder<ResourceResponse>::encodePlatformData(ArgumentEncoder& encode
 {
 }
 
-bool ArgumentCoder<ResourceResponse>::decodePlatformData(ArgumentDecoder* decoder, ResourceResponse& resourceResponse)
+bool ArgumentCoder<ResourceResponse>::decodePlatformData(ArgumentDecoder& decoder, ResourceResponse& resourceResponse)
 {
     return true;
 }
@@ -58,7 +58,7 @@ void ArgumentCoder<ResourceError>::encodePlatformData(ArgumentEncoder& encoder,
 {
 }
 
-bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder* decoder, ResourceError& resourceError)
+bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder& decoder, ResourceError& resourceError)
 {
     return true;
 }