[GTK] Unreviewed GTK build fix since r204665 and 204668
authorjfernandez@igalia.com <jfernandez@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 20 Aug 2016 09:38:41 +0000 (09:38 +0000)
committerjfernandez@igalia.com <jfernandez@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 20 Aug 2016 09:38:41 +0000 (09:38 +0000)
https://bugs.webkit.org/show_bug.cgi?id=161020

* CMakeLists.txt:
* Platform/IPC/MessageRecorder.cpp:
(IPC::MessageRecorder::recordOutgoingMessage):
* Platform/IPC/unix/ConnectionUnix.cpp:
(IPC::Connection::processMessage):
(IPC::Connection::sendOutgoingMessage):
* Platform/unix/SharedMemoryUnix.cpp:
(WebKit::SharedMemory::Handle::encode):
(WebKit::SharedMemory::Handle::decode):
* PlatformGTK.cmake:
* Scripts/webkit/LegacyMessageReceiver-expected.cpp:
(Messages::WebPage::GetPluginProcessConnection::DelayedReply::DelayedReply):
(Messages::WebPage::TestMultipleAttributes::DelayedReply::DelayedReply):
(WebKit::WebPage::didReceiveWebPageMessage):
(WebKit::WebPage::didReceiveSyncWebPageMessage):
* Scripts/webkit/LegacyMessages-expected.h:
* Scripts/webkit/MessageReceiver-expected.cpp:
(Messages::WebPage::GetPluginProcessConnection::DelayedReply::DelayedReply):
(Messages::WebPage::TestMultipleAttributes::DelayedReply::DelayedReply):
(WebKit::WebPage::didReceiveMessage):
(WebKit::WebPage::didReceiveSyncMessage):
* Scripts/webkit/Messages-expected.h:
* Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp:
(IPC::ArgumentCoder<WebCore::FilterOperations>::encode):
(IPC::ArgumentCoder<WebCore::FilterOperations>::decode):
(IPC::ArgumentCoder<TransformOperations>::encode):
(IPC::ArgumentCoder<TransformOperations>::decode):
(IPC::encodeTimingFunction):
(IPC::decodeTimingFunction):
(IPC::ArgumentCoder<TextureMapperAnimation>::encode):
(IPC::ArgumentCoder<TextureMapperAnimation>::decode):
(IPC::ArgumentCoder<TextureMapperAnimations>::encode):
(IPC::ArgumentCoder<TextureMapperAnimations>::decode):
(IPC::ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode):
(IPC::ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode):
(IPC::ArgumentCoder<SurfaceUpdateInfo>::encode):
(IPC::ArgumentCoder<SurfaceUpdateInfo>::decode):
(IPC::ArgumentCoder<CoordinatedGraphicsLayerState>::encode):
(IPC::ArgumentCoder<CoordinatedGraphicsLayerState>::decode):
(IPC::ArgumentCoder<TileUpdateInfo>::encode):
(IPC::ArgumentCoder<TileUpdateInfo>::decode):
(IPC::ArgumentCoder<TileCreationInfo>::encode):
(IPC::ArgumentCoder<TileCreationInfo>::decode):
(IPC::encodeCoordinatedSurface):
(IPC::decodeCoordinatedSurface):
(IPC::ArgumentCoder<CoordinatedGraphicsState>::encode):
(IPC::ArgumentCoder<CoordinatedGraphicsState>::decode):
* Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h:
* Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp:
(WebKit::WebCoordinatedSurface::Handle::encode):
(WebKit::WebCoordinatedSurface::Handle::decode):
* Shared/CoordinatedGraphics/WebCoordinatedSurface.h:
* Shared/WebBatteryStatus.cpp:
(WebKit::WebBatteryStatus::Data::encode):
(WebKit::WebBatteryStatus::Data::decode):
* Shared/WebBatteryStatus.h:
* Shared/gtk/ArgumentCodersGtk.cpp:
(IPC::encodeImage):
(IPC::decodeImage):
(IPC::encodeDataObject):
(IPC::decodeDataObject):
(IPC::ArgumentCoder<DragData>::encode):
(IPC::ArgumentCoder<DragData>::decode):
(IPC::encodeGKeyFile):
(IPC::decodeGKeyFile):
(IPC::encode):
(IPC::decode):
* Shared/gtk/ArgumentCodersGtk.h:
* Shared/soup/WebCoreArgumentCodersSoup.cpp:
(IPC::ArgumentCoder<ResourceRequest>::encodePlatformData):
(IPC::ArgumentCoder<ResourceRequest>::decodePlatformData):
(IPC::ArgumentCoder<CertificateInfo>::encode):
(IPC::ArgumentCoder<CertificateInfo>::decode):
(IPC::ArgumentCoder<ResourceError>::encodePlatformData):
(IPC::ArgumentCoder<ResourceError>::decodePlatformData):
(IPC::ArgumentCoder<ProtectionSpace>::encodePlatformData):
(IPC::ArgumentCoder<ProtectionSpace>::decodePlatformData):
(IPC::ArgumentCoder<Credential>::encodePlatformData):
(IPC::ArgumentCoder<Credential>::decodePlatformData):
* UIProcess/LegacySessionStateCodingNone.cpp:
(WebKit::encodeLegacySessionState):
(WebKit::decodeLegacySessionState):
* UIProcess/WebBatteryManagerProxy.h:

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

20 files changed:
Source/WebKit2/CMakeLists.txt
Source/WebKit2/ChangeLog
Source/WebKit2/Platform/IPC/MessageRecorder.cpp
Source/WebKit2/Platform/IPC/unix/ConnectionUnix.cpp
Source/WebKit2/Platform/unix/SharedMemoryUnix.cpp
Source/WebKit2/Scripts/webkit/LegacyMessageReceiver-expected.cpp
Source/WebKit2/Scripts/webkit/LegacyMessages-expected.h
Source/WebKit2/Scripts/webkit/MessageReceiver-expected.cpp
Source/WebKit2/Scripts/webkit/Messages-expected.h
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/WebBatteryStatus.cpp
Source/WebKit2/Shared/WebBatteryStatus.h
Source/WebKit2/Shared/gtk/ArgumentCodersGtk.cpp
Source/WebKit2/Shared/gtk/ArgumentCodersGtk.h
Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp
Source/WebKit2/UIProcess/LegacySessionStateCodingNone.cpp
Source/WebKit2/UIProcess/WebBatteryManagerProxy.h

index 6dbeb59..4b17772 100644 (file)
@@ -220,8 +220,8 @@ set(WebKit2_SOURCES
     Platform/IPC/Attachment.cpp
     Platform/IPC/Connection.cpp
     Platform/IPC/DataReference.cpp
-    Platform/IPC/Encoder.cpp
     Platform/IPC/Decoder.cpp
+    Platform/IPC/Encoder.cpp
     Platform/IPC/MessageReceiverMap.cpp
     Platform/IPC/MessageSender.cpp
     Platform/IPC/StringReference.cpp
index 25b206f..213b431 100644 (file)
@@ -1,3 +1,92 @@
+2016-08-20  Javier Fernandez  <jfernandez@igalia.com>
+
+        [GTK] Unreviewed GTK build fix since r204665 and 204668
+        https://bugs.webkit.org/show_bug.cgi?id=161020
+
+        * CMakeLists.txt:
+        * Platform/IPC/MessageRecorder.cpp:
+        (IPC::MessageRecorder::recordOutgoingMessage):
+        * Platform/IPC/unix/ConnectionUnix.cpp:
+        (IPC::Connection::processMessage):
+        (IPC::Connection::sendOutgoingMessage):
+        * Platform/unix/SharedMemoryUnix.cpp:
+        (WebKit::SharedMemory::Handle::encode):
+        (WebKit::SharedMemory::Handle::decode):
+        * PlatformGTK.cmake:
+        * Scripts/webkit/LegacyMessageReceiver-expected.cpp:
+        (Messages::WebPage::GetPluginProcessConnection::DelayedReply::DelayedReply):
+        (Messages::WebPage::TestMultipleAttributes::DelayedReply::DelayedReply):
+        (WebKit::WebPage::didReceiveWebPageMessage):
+        (WebKit::WebPage::didReceiveSyncWebPageMessage):
+        * Scripts/webkit/LegacyMessages-expected.h:
+        * Scripts/webkit/MessageReceiver-expected.cpp:
+        (Messages::WebPage::GetPluginProcessConnection::DelayedReply::DelayedReply):
+        (Messages::WebPage::TestMultipleAttributes::DelayedReply::DelayedReply):
+        (WebKit::WebPage::didReceiveMessage):
+        (WebKit::WebPage::didReceiveSyncMessage):
+        * Scripts/webkit/Messages-expected.h:
+        * Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp:
+        (IPC::ArgumentCoder<WebCore::FilterOperations>::encode):
+        (IPC::ArgumentCoder<WebCore::FilterOperations>::decode):
+        (IPC::ArgumentCoder<TransformOperations>::encode):
+        (IPC::ArgumentCoder<TransformOperations>::decode):
+        (IPC::encodeTimingFunction):
+        (IPC::decodeTimingFunction):
+        (IPC::ArgumentCoder<TextureMapperAnimation>::encode):
+        (IPC::ArgumentCoder<TextureMapperAnimation>::decode):
+        (IPC::ArgumentCoder<TextureMapperAnimations>::encode):
+        (IPC::ArgumentCoder<TextureMapperAnimations>::decode):
+        (IPC::ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode):
+        (IPC::ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode):
+        (IPC::ArgumentCoder<SurfaceUpdateInfo>::encode):
+        (IPC::ArgumentCoder<SurfaceUpdateInfo>::decode):
+        (IPC::ArgumentCoder<CoordinatedGraphicsLayerState>::encode):
+        (IPC::ArgumentCoder<CoordinatedGraphicsLayerState>::decode):
+        (IPC::ArgumentCoder<TileUpdateInfo>::encode):
+        (IPC::ArgumentCoder<TileUpdateInfo>::decode):
+        (IPC::ArgumentCoder<TileCreationInfo>::encode):
+        (IPC::ArgumentCoder<TileCreationInfo>::decode):
+        (IPC::encodeCoordinatedSurface):
+        (IPC::decodeCoordinatedSurface):
+        (IPC::ArgumentCoder<CoordinatedGraphicsState>::encode):
+        (IPC::ArgumentCoder<CoordinatedGraphicsState>::decode):
+        * Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h:
+        * Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp:
+        (WebKit::WebCoordinatedSurface::Handle::encode):
+        (WebKit::WebCoordinatedSurface::Handle::decode):
+        * Shared/CoordinatedGraphics/WebCoordinatedSurface.h:
+        * Shared/WebBatteryStatus.cpp:
+        (WebKit::WebBatteryStatus::Data::encode):
+        (WebKit::WebBatteryStatus::Data::decode):
+        * Shared/WebBatteryStatus.h:
+        * Shared/gtk/ArgumentCodersGtk.cpp:
+        (IPC::encodeImage):
+        (IPC::decodeImage):
+        (IPC::encodeDataObject):
+        (IPC::decodeDataObject):
+        (IPC::ArgumentCoder<DragData>::encode):
+        (IPC::ArgumentCoder<DragData>::decode):
+        (IPC::encodeGKeyFile):
+        (IPC::decodeGKeyFile):
+        (IPC::encode):
+        (IPC::decode):
+        * Shared/gtk/ArgumentCodersGtk.h:
+        * Shared/soup/WebCoreArgumentCodersSoup.cpp:
+        (IPC::ArgumentCoder<ResourceRequest>::encodePlatformData):
+        (IPC::ArgumentCoder<ResourceRequest>::decodePlatformData):
+        (IPC::ArgumentCoder<CertificateInfo>::encode):
+        (IPC::ArgumentCoder<CertificateInfo>::decode):
+        (IPC::ArgumentCoder<ResourceError>::encodePlatformData):
+        (IPC::ArgumentCoder<ResourceError>::decodePlatformData):
+        (IPC::ArgumentCoder<ProtectionSpace>::encodePlatformData):
+        (IPC::ArgumentCoder<ProtectionSpace>::decodePlatformData):
+        (IPC::ArgumentCoder<Credential>::encodePlatformData):
+        (IPC::ArgumentCoder<Credential>::decodePlatformData):
+        * UIProcess/LegacySessionStateCodingNone.cpp:
+        (WebKit::encodeLegacySessionState):
+        (WebKit::decodeLegacySessionState):
+        * UIProcess/WebBatteryManagerProxy.h:
+
 2016-08-20  Yusuke Suzuki  <utatane.tea@gmail.com>
 
         Unreviewed, build fix attempt after r204665 and r204668.
index 2d8f3df..9bf7462 100644 (file)
@@ -29,8 +29,8 @@
 #if HAVE(DTRACE)
 
 #include "Connection.h"
-#include "MessageDecoder.h"
-#include "MessageEncoder.h"
+#include "Decoder.h"
+#include "Encoder.h"
 #include "MessageRecorderProbes.h"
 #include <wtf/CurrentTime.h>
 
@@ -41,7 +41,7 @@ bool MessageRecorder::isEnabled()
     return WEBKITMESSAGERECORDER_MESSAGE_RECEIVED_ENABLED() || WEBKITMESSAGERECORDER_MESSAGE_SENT_ENABLED();
 }
 
-std::unique_ptr<MessageRecorder::MessageProcessingToken> MessageRecorder::recordOutgoingMessage(Connection& connection, MessageEncoder& encoder)
+std::unique_ptr<MessageRecorder::MessageProcessingToken> MessageRecorder::recordOutgoingMessage(Connection& connection, Encoder& encoder)
 {
     if (!isEnabled() || !connection.isValid())
         return nullptr;
index 8c3b609..2a8a940 100644 (file)
@@ -245,7 +245,7 @@ bool Connection::processMessage()
     if (messageInfo.isMessageBodyIsOutOfLine())
         messageBody = reinterpret_cast<uint8_t*>(oolMessageBody->data());
 
-    auto decoder = std::make_unique<MessageDecoder>(DataReference(messageBody, messageInfo.bodySize()), WTFMove(attachments));
+    auto decoder = std::make_unique<Decoder>(DataReference(messageBody, messageInfo.bodySize()), WTFMove(attachments));
 
     processIncomingMessage(WTFMove(decoder));
 
@@ -402,7 +402,7 @@ bool Connection::platformCanSendOutgoingMessages() const
     return m_isConnected;
 }
 
-bool Connection::sendOutgoingMessage(std::unique_ptr<MessageEncoder> encoder)
+bool Connection::sendOutgoingMessage(std::unique_ptr<Encoder> encoder)
 {
     COMPILE_ASSERT(sizeof(MessageInfo) + attachmentMaxAmount * sizeof(size_t) <= messageMaxSize, AttachmentsFitToMessageInline);
 
index aa5eaa0..27b25b7 100644 (file)
@@ -29,8 +29,8 @@
 #if USE(UNIX_DOMAIN_SOCKETS)
 #include "SharedMemory.h"
 
-#include "ArgumentDecoder.h"
-#include "ArgumentEncoder.h"
+#include "Decoder.h"
+#include "Encoder.h"
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
@@ -64,12 +64,12 @@ bool SharedMemory::Handle::isNull() const
     return m_attachment.fileDescriptor() == -1;
 }
 
-void SharedMemory::Handle::encode(IPC::ArgumentEncoder& encoder) const
+void SharedMemory::Handle::encode(IPC::Encoder& encoder) const
 {
     encoder << releaseAttachment();
 }
 
-bool SharedMemory::Handle::decode(IPC::ArgumentDecoder& decoder, Handle& handle)
+bool SharedMemory::Handle::decode(IPC::Decoder& decoder, Handle& handle)
 {
     ASSERT_ARG(handle, handle.isNull());
 
index 240fc73..2a0556a 100644 (file)
@@ -37,7 +37,7 @@
 #if PLATFORM(MAC)
 #include "MachPort.h"
 #endif
-#include "MessageDecoder.h"
+#include "Decoder.h"
 #include "Plugin.h"
 #include "WebCoreArgumentCoders.h"
 #if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION && SOME_OTHER_MESSAGE_CONDITION)) || (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION || SOME_OTHER_MESSAGE_CONDITION))
@@ -59,7 +59,7 @@ namespace Messages {
 
 namespace WebPage {
 
-GetPluginProcessConnection::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::MessageEncoder> encoder)
+GetPluginProcessConnection::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::Encoder> encoder)
     : m_connection(connection)
     , m_encoder(WTFMove(encoder))
 {
@@ -79,7 +79,7 @@ bool GetPluginProcessConnection::DelayedReply::send(const IPC::Connection::Handl
     return _result;
 }
 
-TestMultipleAttributes::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::MessageEncoder> encoder)
+TestMultipleAttributes::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::Encoder> encoder)
     : m_connection(connection)
     , m_encoder(WTFMove(encoder))
 {
@@ -104,7 +104,7 @@ bool TestMultipleAttributes::DelayedReply::send()
 
 namespace WebKit {
 
-void WebPage::didReceiveWebPageMessage(IPC::Connection*, IPC::MessageDecoder& decoder)
+void WebPage::didReceiveWebPageMessage(IPC::Connection*, IPC::Decoder& decoder)
 {
     if (decoder.messageName() == Messages::WebPage::LoadURL::name()) {
         IPC::handleMessage<Messages::WebPage::LoadURL>(decoder, this, &WebPage::loadURL);
@@ -188,7 +188,7 @@ void WebPage::didReceiveWebPageMessage(IPC::Connection*, IPC::MessageDecoder& de
     ASSERT_NOT_REACHED();
 }
 
-void WebPage::didReceiveSyncWebPageMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
+void WebPage::didReceiveSyncWebPageMessage(IPC::Connection* connection, IPC::Decoder& decoder, std::unique_ptr<IPC::Encoder>& replyEncoder)
 {
     if (decoder.messageName() == Messages::WebPage::CreatePlugin::name()) {
         IPC::handleMessage<Messages::WebPage::CreatePlugin>(decoder, *replyEncoder, this, &WebPage::createPlugin);
index 6397c10..d0c7625 100644 (file)
@@ -29,7 +29,7 @@
 
 #include "Arguments.h"
 #include "Connection.h"
-#include "MessageEncoder.h"
+#include "Encoder.h"
 #include "Plugin.h"
 #include "StringReference.h"
 #include <WebCore/GraphicsLayer.h>
@@ -365,14 +365,14 @@ public:
     static const bool isSync = true;
 
     struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {
-        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::MessageEncoder>);
+        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::Encoder>);
         ~DelayedReply();
 
         bool send(const IPC::Connection::Handle& connectionHandle);
 
     private:
         RefPtr<IPC::Connection> m_connection;
-        std::unique_ptr<IPC::MessageEncoder> m_encoder;
+        std::unique_ptr<IPC::Encoder> m_encoder;
     };
 
     typedef IPC::Arguments<IPC::Connection::Handle&> Reply;
@@ -399,14 +399,14 @@ public:
     static const bool isSync = true;
 
     struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {
-        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::MessageEncoder>);
+        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::Encoder>);
         ~DelayedReply();
 
         bool send();
 
     private:
         RefPtr<IPC::Connection> m_connection;
-        std::unique_ptr<IPC::MessageEncoder> m_encoder;
+        std::unique_ptr<IPC::Encoder> m_encoder;
     };
 
     typedef IPC::Arguments<> Reply;
index 8d5e13d..b4a1496 100644 (file)
@@ -37,7 +37,7 @@
 #if PLATFORM(MAC)
 #include "MachPort.h"
 #endif
-#include "MessageDecoder.h"
+#include "Decoder.h"
 #include "Plugin.h"
 #include "WebCoreArgumentCoders.h"
 #if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION && SOME_OTHER_MESSAGE_CONDITION)) || (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION || SOME_OTHER_MESSAGE_CONDITION))
@@ -59,7 +59,7 @@ namespace Messages {
 
 namespace WebPage {
 
-GetPluginProcessConnection::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::MessageEncoder> encoder)
+GetPluginProcessConnection::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::Encoder> encoder)
     : m_connection(connection)
     , m_encoder(WTFMove(encoder))
 {
@@ -79,7 +79,7 @@ bool GetPluginProcessConnection::DelayedReply::send(const IPC::Connection::Handl
     return _result;
 }
 
-TestMultipleAttributes::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::MessageEncoder> encoder)
+TestMultipleAttributes::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::Encoder> encoder)
     : m_connection(connection)
     , m_encoder(WTFMove(encoder))
 {
@@ -104,7 +104,7 @@ bool TestMultipleAttributes::DelayedReply::send()
 
 namespace WebKit {
 
-void WebPage::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
+void WebPage::didReceiveMessage(IPC::Connection* connection, IPC::Decoder& decoder)
 {
     if (decoder.messageName() == Messages::WebPage::LoadURL::name()) {
         IPC::handleMessage<Messages::WebPage::LoadURL>(decoder, this, &WebPage::loadURL);
@@ -189,7 +189,7 @@ void WebPage::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder
     ASSERT_NOT_REACHED();
 }
 
-void WebPage::didReceiveSyncMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
+void WebPage::didReceiveSyncMessage(IPC::Connection* connection, IPC::Decoder& decoder, std::unique_ptr<IPC::Encoder>& replyEncoder)
 {
     if (decoder.messageName() == Messages::WebPage::CreatePlugin::name()) {
         IPC::handleMessage<Messages::WebPage::CreatePlugin>(decoder, *replyEncoder, this, &WebPage::createPlugin);
index 6397c10..d0c7625 100644 (file)
@@ -29,7 +29,7 @@
 
 #include "Arguments.h"
 #include "Connection.h"
-#include "MessageEncoder.h"
+#include "Encoder.h"
 #include "Plugin.h"
 #include "StringReference.h"
 #include <WebCore/GraphicsLayer.h>
@@ -365,14 +365,14 @@ public:
     static const bool isSync = true;
 
     struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {
-        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::MessageEncoder>);
+        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::Encoder>);
         ~DelayedReply();
 
         bool send(const IPC::Connection::Handle& connectionHandle);
 
     private:
         RefPtr<IPC::Connection> m_connection;
-        std::unique_ptr<IPC::MessageEncoder> m_encoder;
+        std::unique_ptr<IPC::Encoder> m_encoder;
     };
 
     typedef IPC::Arguments<IPC::Connection::Handle&> Reply;
@@ -399,14 +399,14 @@ public:
     static const bool isSync = true;
 
     struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {
-        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::MessageEncoder>);
+        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::Encoder>);
         ~DelayedReply();
 
         bool send();
 
     private:
         RefPtr<IPC::Connection> m_connection;
-        std::unique_ptr<IPC::MessageEncoder> m_encoder;
+        std::unique_ptr<IPC::Encoder> m_encoder;
     };
 
     typedef IPC::Arguments<> Reply;
index 407b4da..9a87358 100644 (file)
@@ -60,7 +60,7 @@ using namespace WebKit;
 
 namespace IPC {
 
-void ArgumentCoder<WebCore::FilterOperations>::encode(ArgumentEncoder& encoder, const WebCore::FilterOperations& filters)
+void ArgumentCoder<WebCore::FilterOperations>::encode(Encoder& encoder, const WebCore::FilterOperations& filters)
 {
     encoder << static_cast<uint32_t>(filters.size());
     for (size_t i = 0; i < filters.size(); ++i) {
@@ -99,7 +99,7 @@ void ArgumentCoder<WebCore::FilterOperations>::encode(ArgumentEncoder& encoder,
     }
 }
 
-bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder& decoder, WebCore::FilterOperations& filters)
+bool ArgumentCoder<WebCore::FilterOperations>::decode(Decoder& decoder, WebCore::FilterOperations& filters)
 {
     uint32_t size;
     if (!decoder.decode(size))
@@ -168,7 +168,7 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder& decoder,
     return true;
 }
 
-void ArgumentCoder<TransformOperations>::encode(ArgumentEncoder& encoder, const TransformOperations& transformOperations)
+void ArgumentCoder<TransformOperations>::encode(Encoder& encoder, const TransformOperations& transformOperations)
 {
     encoder << static_cast<uint32_t>(transformOperations.size());
     for (const auto& operation : transformOperations.operations()) {
@@ -234,7 +234,7 @@ void ArgumentCoder<TransformOperations>::encode(ArgumentEncoder& encoder, const
     }
 }
 
-bool ArgumentCoder<TransformOperations>::decode(ArgumentDecoder& decoder, TransformOperations& transformOperations)
+bool ArgumentCoder<TransformOperations>::decode(Decoder& decoder, TransformOperations& transformOperations)
 {
     uint32_t operationsSize;
     if (!decoder.decode(operationsSize))
@@ -335,7 +335,7 @@ bool ArgumentCoder<TransformOperations>::decode(ArgumentDecoder& decoder, Transf
     return true;
 }
 
-static void encodeTimingFunction(ArgumentEncoder& encoder, const TimingFunction* timingFunction)
+static void encodeTimingFunction(Encoder& encoder, const TimingFunction* timingFunction)
 {
     if (!timingFunction) {
         encoder.encodeEnum(TimingFunction::TimingFunctionType(-1));
@@ -376,7 +376,7 @@ static void encodeTimingFunction(ArgumentEncoder& encoder, const TimingFunction*
     }
 }
 
-bool decodeTimingFunction(ArgumentDecoder& decoder, RefPtr<TimingFunction>& timingFunction)
+bool decodeTimingFunction(Decoder& decoder, RefPtr<TimingFunction>& timingFunction)
 {
     TimingFunction::TimingFunctionType type;
     if (!decoder.decodeEnum(type))
@@ -443,7 +443,7 @@ bool decodeTimingFunction(ArgumentDecoder& decoder, RefPtr<TimingFunction>& timi
     return false;
 }
 
-void ArgumentCoder<TextureMapperAnimation>::encode(ArgumentEncoder& encoder, const TextureMapperAnimation& animation)
+void ArgumentCoder<TextureMapperAnimation>::encode(Encoder& encoder, const TextureMapperAnimation& animation)
 {
     encoder << animation.name();
     encoder << animation.boxSize();
@@ -482,7 +482,7 @@ void ArgumentCoder<TextureMapperAnimation>::encode(ArgumentEncoder& encoder, con
     }
 }
 
-bool ArgumentCoder<TextureMapperAnimation>::decode(ArgumentDecoder& decoder, TextureMapperAnimation& animation)
+bool ArgumentCoder<TextureMapperAnimation>::decode(Decoder& decoder, TextureMapperAnimation& animation)
 {
     String name;
     FloatSize boxSize;
@@ -575,18 +575,18 @@ bool ArgumentCoder<TextureMapperAnimation>::decode(ArgumentDecoder& decoder, Tex
     return true;
 }
 
-void ArgumentCoder<TextureMapperAnimations>::encode(ArgumentEncoder& encoder, const TextureMapperAnimations& animations)
+void ArgumentCoder<TextureMapperAnimations>::encode(Encoder& encoder, const TextureMapperAnimations& animations)
 {
     encoder << animations.animations();
 }
 
-bool ArgumentCoder<TextureMapperAnimations>::decode(ArgumentDecoder& decoder, TextureMapperAnimations& animations)
+bool ArgumentCoder<TextureMapperAnimations>::decode(Decoder& decoder, TextureMapperAnimations& animations)
 {
     return decoder.decode(animations.animations());
 }
 
 #if USE(GRAPHICS_SURFACE)
-void ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode(ArgumentEncoder& encoder, const WebCore::GraphicsSurfaceToken& token)
+void ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode(Encoder& encoder, const WebCore::GraphicsSurfaceToken& token)
 {
 #if OS(DARWIN)
     encoder << Attachment(token.frontBufferHandle, MACH_MSG_TYPE_MOVE_SEND);
@@ -596,7 +596,7 @@ void ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode(ArgumentEncoder& encod
 #endif
 }
 
-bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(ArgumentDecoder& decoder, WebCore::GraphicsSurfaceToken& token)
+bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(Decoder& decoder, WebCore::GraphicsSurfaceToken& token)
 {
 #if OS(DARWIN)
     Attachment frontAttachment, backAttachment;
@@ -614,17 +614,17 @@ bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(ArgumentDecoder& decod
 }
 #endif
 
-void ArgumentCoder<SurfaceUpdateInfo>::encode(ArgumentEncoder& encoder, const SurfaceUpdateInfo& surfaceUpdateInfo)
+void ArgumentCoder<SurfaceUpdateInfo>::encode(Encoder& encoder, const SurfaceUpdateInfo& surfaceUpdateInfo)
 {
     SimpleArgumentCoder<SurfaceUpdateInfo>::encode(encoder, surfaceUpdateInfo);
 }
 
-bool ArgumentCoder<SurfaceUpdateInfo>::decode(ArgumentDecoder& decoder, SurfaceUpdateInfo& surfaceUpdateInfo)
+bool ArgumentCoder<SurfaceUpdateInfo>::decode(Decoder& decoder, SurfaceUpdateInfo& surfaceUpdateInfo)
 {
     return SimpleArgumentCoder<SurfaceUpdateInfo>::decode(decoder, surfaceUpdateInfo);
 }
 
-void ArgumentCoder<CoordinatedGraphicsLayerState>::encode(ArgumentEncoder& encoder, const CoordinatedGraphicsLayerState& state)
+void ArgumentCoder<CoordinatedGraphicsLayerState>::encode(Encoder& encoder, const CoordinatedGraphicsLayerState& state)
 {
     encoder << state.changeMask;
 
@@ -705,7 +705,7 @@ void ArgumentCoder<CoordinatedGraphicsLayerState>::encode(ArgumentEncoder& encod
         encoder << state.committedScrollOffset;
 }
 
-bool ArgumentCoder<CoordinatedGraphicsLayerState>::decode(ArgumentDecoder& decoder, CoordinatedGraphicsLayerState& state)
+bool ArgumentCoder<CoordinatedGraphicsLayerState>::decode(Decoder& decoder, CoordinatedGraphicsLayerState& state)
 {
     if (!decoder.decode(state.changeMask))
         return false;
@@ -802,27 +802,27 @@ bool ArgumentCoder<CoordinatedGraphicsLayerState>::decode(ArgumentDecoder& decod
     return true;
 }
 
-void ArgumentCoder<TileUpdateInfo>::encode(ArgumentEncoder& encoder, const TileUpdateInfo& updateInfo)
+void ArgumentCoder<TileUpdateInfo>::encode(Encoder& encoder, const TileUpdateInfo& updateInfo)
 {
     SimpleArgumentCoder<TileUpdateInfo>::encode(encoder, updateInfo);
 }
 
-bool ArgumentCoder<TileUpdateInfo>::decode(ArgumentDecoder& decoder, TileUpdateInfo& updateInfo)
+bool ArgumentCoder<TileUpdateInfo>::decode(Decoder& decoder, TileUpdateInfo& updateInfo)
 {
     return SimpleArgumentCoder<TileUpdateInfo>::decode(decoder, updateInfo);
 }
 
-void ArgumentCoder<TileCreationInfo>::encode(ArgumentEncoder& encoder, const TileCreationInfo& updateInfo)
+void ArgumentCoder<TileCreationInfo>::encode(Encoder& encoder, const TileCreationInfo& updateInfo)
 {
     SimpleArgumentCoder<TileCreationInfo>::encode(encoder, updateInfo);
 }
 
-bool ArgumentCoder<TileCreationInfo>::decode(ArgumentDecoder& decoder, TileCreationInfo& updateInfo)
+bool ArgumentCoder<TileCreationInfo>::decode(Decoder& decoder, TileCreationInfo& updateInfo)
 {
     return SimpleArgumentCoder<TileCreationInfo>::decode(decoder, updateInfo);
 }
 
-static void encodeCoordinatedSurface(ArgumentEncoder& encoder, const RefPtr<CoordinatedSurface>& surface)
+static void encodeCoordinatedSurface(Encoder& encoder, const RefPtr<CoordinatedSurface>& surface)
 {
     bool isValidSurface = false;
     if (!surface) {
@@ -841,7 +841,7 @@ static void encodeCoordinatedSurface(ArgumentEncoder& encoder, const RefPtr<Coor
         encoder << handle;
 }
 
-static bool decodeCoordinatedSurface(ArgumentDecoder& decoder, RefPtr<CoordinatedSurface>& surface)
+static bool decodeCoordinatedSurface(Decoder& decoder, RefPtr<CoordinatedSurface>& surface)
 {
     bool isValidSurface;
     if (!decoder.decode(isValidSurface))
@@ -858,7 +858,7 @@ static bool decodeCoordinatedSurface(ArgumentDecoder& decoder, RefPtr<Coordinate
     return true;
 }
 
-void ArgumentCoder<CoordinatedGraphicsState>::encode(ArgumentEncoder& encoder, const CoordinatedGraphicsState& state)
+void ArgumentCoder<CoordinatedGraphicsState>::encode(Encoder& encoder, const CoordinatedGraphicsState& state)
 {
     encoder << state.rootCompositingLayer;
     encoder << state.scrollPosition;
@@ -889,7 +889,7 @@ void ArgumentCoder<CoordinatedGraphicsState>::encode(ArgumentEncoder& encoder, c
     encoder << state.updateAtlasesToRemove;
 }
 
-bool ArgumentCoder<CoordinatedGraphicsState>::decode(ArgumentDecoder& decoder, CoordinatedGraphicsState& state)
+bool ArgumentCoder<CoordinatedGraphicsState>::decode(Decoder& decoder, CoordinatedGraphicsState& state)
 {
     if (!decoder.decode(state.rootCompositingLayer))
         return false;
index ecdd014..f724aaa 100644 (file)
@@ -54,55 +54,55 @@ struct GraphicsSurfaceToken;
 namespace IPC {
 
 template<> struct ArgumentCoder<WebCore::FilterOperations> {
-    static void encode(ArgumentEncoder&, const WebCore::FilterOperations&);
-    static bool decode(ArgumentDecoder&, WebCore::FilterOperations&);
+    static void encode(Encoder&, const WebCore::FilterOperations&);
+    static bool decode(Decoder&, WebCore::FilterOperations&);
 };
 
 template<> struct ArgumentCoder<WebCore::TransformOperations> {
-    static void encode(ArgumentEncoder&, const WebCore::TransformOperations&);
-    static bool decode(ArgumentDecoder&, WebCore::TransformOperations&);
+    static void encode(Encoder&, const WebCore::TransformOperations&);
+    static bool decode(Decoder&, WebCore::TransformOperations&);
 };
 
 template<> struct ArgumentCoder<WebCore::TextureMapperAnimations> {
-    static void encode(ArgumentEncoder&, const WebCore::TextureMapperAnimations&);
-    static bool decode(ArgumentDecoder&, WebCore::TextureMapperAnimations&);
+    static void encode(Encoder&, const WebCore::TextureMapperAnimations&);
+    static bool decode(Decoder&, WebCore::TextureMapperAnimations&);
 };
 
 template<> struct ArgumentCoder<WebCore::TextureMapperAnimation> {
-    static void encode(ArgumentEncoder&, const WebCore::TextureMapperAnimation&);
-    static bool decode(ArgumentDecoder&, WebCore::TextureMapperAnimation&);
+    static void encode(Encoder&, const WebCore::TextureMapperAnimation&);
+    static bool decode(Decoder&, WebCore::TextureMapperAnimation&);
 };
 
 #if USE(GRAPHICS_SURFACE)
 template<> struct ArgumentCoder<WebCore::GraphicsSurfaceToken> {
-    static void encode(ArgumentEncoder&, const WebCore::GraphicsSurfaceToken&);
-    static bool decode(ArgumentDecoder&, WebCore::GraphicsSurfaceToken&);
+    static void encode(Encoder&, const WebCore::GraphicsSurfaceToken&);
+    static bool decode(Decoder&, WebCore::GraphicsSurfaceToken&);
 };
 #endif
 
 template<> struct ArgumentCoder<WebCore::SurfaceUpdateInfo> {
-    static void encode(ArgumentEncoder&, const WebCore::SurfaceUpdateInfo&);
-    static bool decode(ArgumentDecoder&, WebCore::SurfaceUpdateInfo&);
+    static void encode(Encoder&, const WebCore::SurfaceUpdateInfo&);
+    static bool decode(Decoder&, WebCore::SurfaceUpdateInfo&);
 };
 
 template<> struct ArgumentCoder<WebCore::CoordinatedGraphicsLayerState> {
-    static void encode(ArgumentEncoder&, const WebCore::CoordinatedGraphicsLayerState&);
-    static bool decode(ArgumentDecoder&, WebCore::CoordinatedGraphicsLayerState&);
+    static void encode(Encoder&, const WebCore::CoordinatedGraphicsLayerState&);
+    static bool decode(Decoder&, WebCore::CoordinatedGraphicsLayerState&);
 };
 
 template<> struct ArgumentCoder<WebCore::TileUpdateInfo> {
-    static void encode(ArgumentEncoder&, const WebCore::TileUpdateInfo&);
-    static bool decode(ArgumentDecoder&, WebCore::TileUpdateInfo&);
+    static void encode(Encoder&, const WebCore::TileUpdateInfo&);
+    static bool decode(Decoder&, WebCore::TileUpdateInfo&);
 };
 
 template<> struct ArgumentCoder<WebCore::TileCreationInfo> {
-    static void encode(ArgumentEncoder&, const WebCore::TileCreationInfo&);
-    static bool decode(ArgumentDecoder&, WebCore::TileCreationInfo&);
+    static void encode(Encoder&, const WebCore::TileCreationInfo&);
+    static bool decode(Decoder&, WebCore::TileCreationInfo&);
 };
 
 template<> struct ArgumentCoder<WebCore::CoordinatedGraphicsState> {
-    static void encode(ArgumentEncoder&, const WebCore::CoordinatedGraphicsState&);
-    static bool decode(ArgumentDecoder&, WebCore::CoordinatedGraphicsState&);
+    static void encode(Encoder&, const WebCore::CoordinatedGraphicsState&);
+    static bool decode(Decoder&, WebCore::CoordinatedGraphicsState&);
 };
 
 } // namespace IPC
index e328907..2c5c12f 100644 (file)
@@ -40,7 +40,7 @@ WebCoordinatedSurface::Handle::Handle()
 {
 }
 
-void WebCoordinatedSurface::Handle::encode(IPC::ArgumentEncoder& encoder) const
+void WebCoordinatedSurface::Handle::encode(IPC::Encoder& encoder) const
 {
     encoder << m_size << m_flags;
 #if USE(GRAPHICS_SURFACE)
@@ -51,7 +51,7 @@ void WebCoordinatedSurface::Handle::encode(IPC::ArgumentEncoder& encoder) const
     encoder << m_bitmapHandle;
 }
 
-bool WebCoordinatedSurface::Handle::decode(IPC::ArgumentDecoder& decoder, Handle& handle)
+bool WebCoordinatedSurface::Handle::decode(IPC::Decoder& decoder, Handle& handle)
 {
     if (!decoder.decode(handle.m_size))
         return false;
index 6d7062b..6ab7c64 100644 (file)
@@ -43,8 +43,8 @@ public:
     public:
         Handle();
 
-        void encode(IPC::ArgumentEncoder&) const;
-        static bool decode(IPC::ArgumentDecoder&, Handle&);
+        void encode(IPC::Encoder&) const;
+        static bool decode(IPC::Decoder&, Handle&);
 
 #if USE(GRAPHICS_SURFACE)
         WebCore::GraphicsSurfaceToken graphicsSurfaceToken() const { return m_graphicsSurfaceToken; }
index d012d70..8157b45 100644 (file)
@@ -45,7 +45,7 @@ WebBatteryStatus::~WebBatteryStatus()
 {
 }
 
-void WebBatteryStatus::Data::encode(IPC::ArgumentEncoder& encoder) const
+void WebBatteryStatus::Data::encode(IPC::Encoder& encoder) const
 {
     encoder << isCharging;
     encoder << chargingTime;
@@ -53,7 +53,7 @@ void WebBatteryStatus::Data::encode(IPC::ArgumentEncoder& encoder) const
     encoder << level;
 }
 
-bool WebBatteryStatus::Data::decode(IPC::ArgumentDecoder& decoder, Data& result)
+bool WebBatteryStatus::Data::decode(IPC::Decoder& decoder, Data& result)
 {
     if (!decoder.decode(result.isCharging))
         return false;
index 227a332..349a8f0 100644 (file)
 #if ENABLE(BATTERY_STATUS)
 
 #include "APIObject.h"
-#include "ArgumentDecoder.h"
-#include "ArgumentEncoder.h"
+#include "Decoder.h"
+#include "Encoder.h"
 
 namespace WebKit {
 
 class WebBatteryStatus : public API::ObjectImpl<API::Object::Type::BatteryStatus> {
 public:
     struct Data {
-        void encode(IPC::ArgumentEncoder&) const;
-        static bool decode(IPC::ArgumentDecoder&, Data&);
+        void encode(IPC::Encoder&) const;
+        static bool decode(IPC::Decoder&, Data&);
 
         bool isCharging;
         double chargingTime;
index 7a2d6c4..fd945a0 100644 (file)
@@ -41,7 +41,7 @@ using namespace WebKit;
 
 namespace IPC {
 
-static void encodeImage(ArgumentEncoder& encoder, const GdkPixbuf* pixbuf)
+static void encodeImage(Encoder& encoder, const GdkPixbuf* pixbuf)
 {
     IntSize imageSize(gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(imageSize, ShareableBitmap::SupportsAlpha);
@@ -57,7 +57,7 @@ static void encodeImage(ArgumentEncoder& encoder, const GdkPixbuf* pixbuf)
     encoder << handle;
 }
 
-static bool decodeImage(ArgumentDecoder& decoder, GRefPtr<GdkPixbuf>& pixbuf)
+static bool decodeImage(Decoder& decoder, GRefPtr<GdkPixbuf>& pixbuf)
 {
     ShareableBitmap::Handle handle;
     if (!decoder.decode(handle))
@@ -82,7 +82,7 @@ static bool decodeImage(ArgumentDecoder& decoder, GRefPtr<GdkPixbuf>& pixbuf)
     return true;
 }
 
-static void encodeDataObject(ArgumentEncoder& encoder, const DataObjectGtk* dataObject)
+static void encodeDataObject(Encoder& encoder, const DataObjectGtk* dataObject)
 {
     bool hasText = dataObject->hasText();
     encoder << hasText;
@@ -115,7 +115,7 @@ static void encodeDataObject(ArgumentEncoder& encoder, const DataObjectGtk* data
         encoder << dataObject->unknownTypes();
 }
 
-static bool decodeDataObject(ArgumentDecoder& decoder, RefPtr<DataObjectGtk>& dataObject)
+static bool decodeDataObject(Decoder& decoder, RefPtr<DataObjectGtk>& dataObject)
 {
     RefPtr<DataObjectGtk> data = DataObjectGtk::create();
 
@@ -188,7 +188,7 @@ static bool decodeDataObject(ArgumentDecoder& decoder, RefPtr<DataObjectGtk>& da
 }
 
 #if ENABLE(DRAG_SUPPORT)
-void ArgumentCoder<DragData>::encode(ArgumentEncoder& encoder, const DragData& dragData)
+void ArgumentCoder<DragData>::encode(Encoder& encoder, const DragData& dragData)
 {
     encoder << dragData.clientPosition();
     encoder << dragData.globalPosition();
@@ -201,7 +201,7 @@ void ArgumentCoder<DragData>::encode(ArgumentEncoder& encoder, const DragData& d
         encodeDataObject(encoder, platformData);
 }
 
-bool ArgumentCoder<DragData>::decode(ArgumentDecoder& decoder, DragData& dragData)
+bool ArgumentCoder<DragData>::decode(Decoder& decoder, DragData& dragData)
 {
     IntPoint clientPosition;
     if (!decoder.decode(clientPosition))
@@ -236,14 +236,14 @@ bool ArgumentCoder<DragData>::decode(ArgumentDecoder& decoder, DragData& dragDat
 }
 #endif // ENABLE(DRAG_SUPPORT)
 
-static void encodeGKeyFile(ArgumentEncoder& encoder, GKeyFile* keyFile)
+static void encodeGKeyFile(Encoder& encoder, GKeyFile* keyFile)
 {
     gsize dataSize;
     GUniquePtr<char> data(g_key_file_to_data(keyFile, &dataSize, 0));
     encoder << DataReference(reinterpret_cast<uint8_t*>(data.get()), dataSize);
 }
 
-static bool decodeGKeyFile(ArgumentDecoder& decoder, GUniquePtr<GKeyFile>& keyFile)
+static bool decodeGKeyFile(Decoder& decoder, GUniquePtr<GKeyFile>& keyFile)
 {
     DataReference dataReference;
     if (!decoder.decode(dataReference))
@@ -261,14 +261,14 @@ static bool decodeGKeyFile(ArgumentDecoder& decoder, GUniquePtr<GKeyFile>& keyFi
     return true;
 }
 
-void encode(ArgumentEncoder& encoder, GtkPrintSettings* printSettings)
+void encode(Encoder& encoder, GtkPrintSettings* printSettings)
 {
     GUniquePtr<GKeyFile> keyFile(g_key_file_new());
     gtk_print_settings_to_key_file(printSettings, keyFile.get(), "Print Settings");
     encodeGKeyFile(encoder, keyFile.get());
 }
 
-bool decode(ArgumentDecoder& decoder, GRefPtr<GtkPrintSettings>& printSettings)
+bool decode(Decoder& decoder, GRefPtr<GtkPrintSettings>& printSettings)
 {
     GUniquePtr<GKeyFile> keyFile;
     if (!decodeGKeyFile(decoder, keyFile))
@@ -284,14 +284,14 @@ bool decode(ArgumentDecoder& decoder, GRefPtr<GtkPrintSettings>& printSettings)
     return printSettings;
 }
 
-void encode(ArgumentEncoder& encoder, GtkPageSetup* pageSetup)
+void encode(Encoder& encoder, GtkPageSetup* pageSetup)
 {
     GUniquePtr<GKeyFile> keyFile(g_key_file_new());
     gtk_page_setup_to_key_file(pageSetup, keyFile.get(), "Page Setup");
     encodeGKeyFile(encoder, keyFile.get());
 }
 
-bool decode(ArgumentDecoder& decoder, GRefPtr<GtkPageSetup>& pageSetup)
+bool decode(Decoder& decoder, GRefPtr<GtkPageSetup>& pageSetup)
 {
     GUniquePtr<GKeyFile> keyFile;
     if (!decodeGKeyFile(decoder, keyFile))
index 80a5dc1..01ac4cf 100644 (file)
@@ -41,16 +41,16 @@ namespace IPC {
 
 #if ENABLE(DRAG_SUPPORT)
 template<> struct ArgumentCoder<WebCore::DragData> {
-    static void encode(ArgumentEncoder&, const WebCore::DragData&);
-    static bool decode(ArgumentDecoder&, WebCore::DragData&);
+    static void encode(Encoder&, const WebCore::DragData&);
+    static bool decode(Decoder&, WebCore::DragData&);
 };
 #endif
 
-void encode(ArgumentEncoder&, GtkPrintSettings*);
-bool decode(ArgumentDecoder&, GRefPtr<GtkPrintSettings>&);
+void encode(Encoder&, GtkPrintSettings*);
+bool decode(Decoder&, GRefPtr<GtkPrintSettings>&);
 
-void encode(ArgumentEncoder&, GtkPageSetup*);
-bool decode(ArgumentDecoder&, GRefPtr<GtkPageSetup>&);
+void encode(Encoder&, GtkPageSetup*);
+bool decode(Decoder&, GRefPtr<GtkPageSetup>&);
 
 } // namespace IPC
 
index 7ed6762..0f972c0 100644 (file)
@@ -39,7 +39,7 @@ using namespace WebCore;
 
 namespace IPC {
 
-void ArgumentCoder<ResourceRequest>::encodePlatformData(ArgumentEncoder& encoder, const ResourceRequest& resourceRequest)
+void ArgumentCoder<ResourceRequest>::encodePlatformData(Encoder& encoder, const ResourceRequest& resourceRequest)
 {
     encoder << resourceRequest.url().string();
     encoder << resourceRequest.httpMethod();
@@ -64,7 +64,7 @@ void ArgumentCoder<ResourceRequest>::encodePlatformData(ArgumentEncoder& encoder
     encoder << resourceRequest.initiatingPageID();
 }
 
-bool ArgumentCoder<ResourceRequest>::decodePlatformData(ArgumentDecoder& decoder, ResourceRequest& resourceRequest)
+bool ArgumentCoder<ResourceRequest>::decodePlatformData(Decoder& decoder, ResourceRequest& resourceRequest)
 {
     String url;
     if (!decoder.decode(url))
@@ -134,7 +134,7 @@ bool ArgumentCoder<ResourceRequest>::decodePlatformData(ArgumentDecoder& decoder
     return true;
 }
 
-void ArgumentCoder<CertificateInfo>::encode(ArgumentEncoder& encoder, const CertificateInfo& certificateInfo)
+void ArgumentCoder<CertificateInfo>::encode(Encoder& encoder, const CertificateInfo& certificateInfo)
 {
     if (!certificateInfo.certificate()) {
         encoder << false;
@@ -154,7 +154,7 @@ void ArgumentCoder<CertificateInfo>::encode(ArgumentEncoder& encoder, const Cert
     encoder << static_cast<uint32_t>(certificateInfo.tlsErrors());
 }
 
-bool ArgumentCoder<CertificateInfo>::decode(ArgumentDecoder& decoder, CertificateInfo& certificateInfo)
+bool ArgumentCoder<CertificateInfo>::decode(Decoder& decoder, CertificateInfo& certificateInfo)
 {
     bool hasCertificate;
     if (!decoder.decode(hasCertificate))
@@ -184,7 +184,7 @@ bool ArgumentCoder<CertificateInfo>::decode(ArgumentDecoder& decoder, Certificat
     return true;
 }
 
-void ArgumentCoder<ResourceError>::encodePlatformData(ArgumentEncoder& encoder, const ResourceError& resourceError)
+void ArgumentCoder<ResourceError>::encodePlatformData(Encoder& encoder, const ResourceError& resourceError)
 {
     encoder.encodeEnum(resourceError.type());
     if (resourceError.isNull())
@@ -198,7 +198,7 @@ void ArgumentCoder<ResourceError>::encodePlatformData(ArgumentEncoder& encoder,
     encoder << CertificateInfo(resourceError);
 }
 
-bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder& decoder, ResourceError& resourceError)
+bool ArgumentCoder<ResourceError>::decodePlatformData(Decoder& decoder, ResourceError& resourceError)
 {
     ResourceErrorBase::Type errorType;
     if (!decoder.decodeEnum(errorType))
@@ -236,23 +236,23 @@ bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder& decoder,
     return true;
 }
 
-void ArgumentCoder<ProtectionSpace>::encodePlatformData(ArgumentEncoder&, const ProtectionSpace&)
+void ArgumentCoder<ProtectionSpace>::encodePlatformData(Encoder&, const ProtectionSpace&)
 {
     ASSERT_NOT_REACHED();
 }
 
-bool ArgumentCoder<ProtectionSpace>::decodePlatformData(ArgumentDecoder&, ProtectionSpace&)
+bool ArgumentCoder<ProtectionSpace>::decodePlatformData(Decoder&, ProtectionSpace&)
 {
     ASSERT_NOT_REACHED();
     return false;
 }
 
-void ArgumentCoder<Credential>::encodePlatformData(ArgumentEncoder&, const Credential&)
+void ArgumentCoder<Credential>::encodePlatformData(Encoder&, const Credential&)
 {
     ASSERT_NOT_REACHED();
 }
 
-bool ArgumentCoder<Credential>::decodePlatformData(ArgumentDecoder&, Credential&)
+bool ArgumentCoder<Credential>::decodePlatformData(Decoder&, Credential&)
 {
     ASSERT_NOT_REACHED();
     return false;
index 4627bc9..303f915 100644 (file)
@@ -27,8 +27,9 @@
 #include "LegacySessionStateCoding.h"
 
 #include "APIData.h"
-#include "ArgumentDecoder.h"
-#include "ArgumentEncoder.h"
+#include "DataReference.h"
+#include "Decoder.h"
+#include "Encoder.h"
 #include "SessionState.h"
 #include "WebCoreArgumentCoders.h"
 
@@ -36,7 +37,8 @@ namespace WebKit {
 
 RefPtr<API::Data> encodeLegacySessionState(const SessionState& sessionState)
 {
-    IPC::ArgumentEncoder encoder;
+    // FIXME: I'm not sure whether these are the proper arguments for the encoder.
+    IPC::Encoder encoder("IPC", "LegacySessionState", 0);
     encoder << sessionState.backForwardListState;
     encoder << sessionState.renderTreeSize;
     encoder << sessionState.provisionalURL;
@@ -45,7 +47,7 @@ RefPtr<API::Data> encodeLegacySessionState(const SessionState& sessionState)
 
 bool decodeLegacySessionState(const uint8_t* data, size_t dataSize, SessionState& sessionState)
 {
-    IPC::ArgumentDecoder decoder(data, dataSize);
+    IPC::Decoder decoder(IPC::DataReference(data, dataSize), Vector<IPC::Attachment>());
     if (!decoder.decode(sessionState.backForwardListState))
         return false;
     if (!decoder.decode(sessionState.renderTreeSize))
index 6873284..c97a88e 100644 (file)
@@ -64,7 +64,7 @@ private:
     void derefWebContextSupplement() override;
 
     // IPC::MessageReceiver
-    void didReceiveMessage(IPC::Connection&, IPC::MessageDecoder&) override;
+    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
 
     void startUpdating();
     void stopUpdating();