Message decoding functions should take a MessageDecoder reference
authorandersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 1 Feb 2013 19:53:44 +0000 (19:53 +0000)
committerandersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 1 Feb 2013 19:53:44 +0000 (19:53 +0000)
https://bugs.webkit.org/show_bug.cgi?id=108669

Reviewed by Andreas Kling.

Message encoding functions already take a reference instead of a pointer, so
make the decoding functions take a reference as well.

* Platform/CoreIPC/ArgumentCoder.h:
(CoreIPC::ArgumentCoder::decode):
* Platform/CoreIPC/ArgumentCoders.cpp:
(CoreIPC::::decode):
(CoreIPC::decodeStringText):
* Platform/CoreIPC/ArgumentCoders.h:
(CoreIPC::SimpleArgumentCoder::decode):
* Platform/CoreIPC/ArgumentDecoder.h:
(CoreIPC::ArgumentDecoder::decode):
* Platform/CoreIPC/Arguments.h:
(CoreIPC::Arguments0::decode):
(CoreIPC::Arguments1::decode):
(CoreIPC::Arguments2::decode):
(CoreIPC::Arguments3::decode):
(CoreIPC::Arguments4::decode):
(CoreIPC::Arguments5::decode):
(CoreIPC::Arguments6::decode):
(CoreIPC::Arguments7::decode):
(CoreIPC::Arguments8::decode):
(CoreIPC::Arguments10::decode):
* Platform/CoreIPC/Attachment.cpp:
(CoreIPC::Attachment::decode):
* Platform/CoreIPC/Attachment.h:
(Attachment):
* Platform/CoreIPC/DataReference.cpp:
(CoreIPC::DataReference::decode):
* Platform/CoreIPC/DataReference.h:
(DataReference):
* Platform/CoreIPC/StringReference.cpp:
(CoreIPC::StringReference::decode):
* Platform/CoreIPC/StringReference.h:
(StringReference):
* Platform/CoreIPC/mac/MachPort.h:
(CoreIPC::MachPort::decode):
* Platform/SharedMemory.h:
(Handle):
* Platform/mac/SharedMemoryMac.cpp:
(WebKit::SharedMemory::Handle::decode):
* PluginProcess/PluginCreationParameters.cpp:
(WebKit::PluginCreationParameters::decode):
* PluginProcess/PluginCreationParameters.h:
(PluginCreationParameters):
* Shared/DictionaryPopupInfo.cpp:
(WebKit::DictionaryPopupInfo::decode):
* Shared/DictionaryPopupInfo.h:
(DictionaryPopupInfo):
* Shared/EditorState.cpp:
(WebKit::EditorState::decode):
* Shared/EditorState.h:
(EditorState):
* Shared/FontInfo.cpp:
(WebKit::FontInfo::decode):
* Shared/FontInfo.h:
(FontInfo):
* Shared/LayerTreeContext.h:
(LayerTreeContext):
* Shared/Network/NetworkProcessCreationParameters.cpp:
(WebKit::NetworkProcessCreationParameters::decode):
* Shared/Network/NetworkProcessCreationParameters.h:
(NetworkProcessCreationParameters):
* Shared/Network/NetworkResourceLoadParameters.cpp:
(WebKit::NetworkResourceLoadParameters::decode):
* Shared/Network/NetworkResourceLoadParameters.h:
(NetworkResourceLoadParameters):
* Shared/OriginAndDatabases.cpp:
(WebKit::OriginAndDatabases::decode):
* Shared/OriginAndDatabases.h:
(OriginAndDatabases):
* Shared/PlatformPopupMenuData.cpp:
(WebKit::PlatformPopupMenuData::decode):
* Shared/PlatformPopupMenuData.h:
(PlatformPopupMenuData):
* Shared/Plugins/NPIdentifierData.cpp:
(WebKit::NPIdentifierData::decode):
* Shared/Plugins/NPIdentifierData.h:
(NPIdentifierData):
* Shared/Plugins/NPVariantData.cpp:
(WebKit::NPVariantData::decode):
* Shared/Plugins/NPVariantData.h:
(NPVariantData):
* Shared/Plugins/PluginProcessCreationParameters.cpp:
(WebKit::PluginProcessCreationParameters::decode):
* Shared/Plugins/PluginProcessCreationParameters.h:
(PluginProcessCreationParameters):
* Shared/PrintInfo.cpp:
(WebKit::PrintInfo::decode):
* Shared/PrintInfo.h:
(PrintInfo):
* Shared/SandboxExtension.h:
(Handle):
(HandleArray):
(WebKit::SandboxExtension::Handle::decode):
(WebKit::SandboxExtension::HandleArray::decode):
* Shared/SecurityOriginData.cpp:
(WebKit::SecurityOriginData::decode):
* Shared/SecurityOriginData.h:
(SecurityOriginData):
* Shared/SessionState.cpp:
(WebKit::SessionState::decode):
* Shared/SessionState.h:
(SessionState):
* Shared/ShareableBitmap.cpp:
(WebKit::ShareableBitmap::Handle::decode):
* Shared/ShareableBitmap.h:
(Handle):
* Shared/ShareableResource.cpp:
(WebKit::ShareableResource::Handle::decode):
* Shared/ShareableResource.h:
(Handle):
* Shared/SharedWorkerProcessCreationParameters.cpp:
(WebKit::SharedWorkerProcessCreationParameters::decode):
* Shared/SharedWorkerProcessCreationParameters.h:
(SharedWorkerProcessCreationParameters):
* Shared/StatisticsData.cpp:
(WebKit::StatisticsData::decode):
* Shared/StatisticsData.h:
(StatisticsData):
* Shared/StringPairVector.h:
(WebKit::StringPairVector::decode):
* Shared/UpdateInfo.cpp:
(WebKit::UpdateInfo::decode):
* Shared/UpdateInfo.h:
(UpdateInfo):
* Shared/UserMessageCoders.h:
(WebKit::UserMessageDecoder::baseDecode):
* Shared/WebContextMenuItemData.cpp:
(WebKit::WebContextMenuItemData::decode):
* Shared/WebContextMenuItemData.h:
(WebContextMenuItemData):
* Shared/WebCoreArgumentCoders.cpp:
(CoreIPC::::decode):
(CoreIPC::decodeImage):
* Shared/WebCoreArgumentCoders.h:
* Shared/WebEvent.cpp:
(WebKit::WebEvent::decode):
* Shared/WebEvent.h:
(WebEvent):
(WebMouseEvent):
(WebWheelEvent):
(WebKeyboardEvent):
(WebGestureEvent):
(WebPlatformTouchPoint):
(WebTouchEvent):
* Shared/WebGeolocationPosition.cpp:
(WebKit::WebGeolocationPosition::Data::decode):
* Shared/WebGeolocationPosition.h:
(Data):
* Shared/WebGestureEvent.cpp:
(WebKit::WebGestureEvent::decode):
* Shared/WebHitTestResult.cpp:
(WebKit::WebHitTestResult::Data::decode):
* Shared/WebHitTestResult.h:
(Data):
* Shared/WebKeyboardEvent.cpp:
(WebKit::WebKeyboardEvent::decode):
* Shared/WebMouseEvent.cpp:
(WebKit::WebMouseEvent::decode):
* Shared/WebNavigationDataStore.h:
(WebKit::WebNavigationDataStore::decode):
* Shared/WebPageCreationParameters.cpp:
(WebKit::WebPageCreationParameters::decode):
* Shared/WebPageCreationParameters.h:
(WebPageCreationParameters):
* Shared/WebPageGroupData.cpp:
(WebKit::WebPageGroupData::decode):
* Shared/WebPageGroupData.h:
(WebPageGroupData):
* Shared/WebPlatformTouchPoint.cpp:
(WebKit::WebPlatformTouchPoint::decode):
* Shared/WebPopupItem.cpp:
(WebKit::WebPopupItem::decode):
* Shared/WebPopupItem.h:
* Shared/WebPreferencesStore.cpp:
(WebKit::WebPreferencesStore::decode):
* Shared/WebPreferencesStore.h:
(WebPreferencesStore):
* Shared/WebProcessCreationParameters.cpp:
(WebKit::WebProcessCreationParameters::decode):
* Shared/WebProcessCreationParameters.h:
(WebProcessCreationParameters):
* Shared/WebTouchEvent.cpp:
(WebKit::WebTouchEvent::decode):
* Shared/WebWheelEvent.cpp:
(WebKit::WebWheelEvent::decode):
* Shared/cf/ArgumentCodersCF.cpp:
(CoreIPC::decode):
* Shared/cf/ArgumentCodersCF.h:
(CoreIPC):
* Shared/mac/ArgumentCodersMac.h:
(CoreIPC):
* Shared/mac/ArgumentCodersMac.mm:
(CoreIPC::decode):
* Shared/mac/AttributedString.h:
(AttributedString):
* Shared/mac/AttributedString.mm:
(WebKit::AttributedString::decode):
* Shared/mac/ColorSpaceData.h:
(ColorSpaceData):
* Shared/mac/ColorSpaceData.mm:
(WebKit::ColorSpaceData::decode):
* Shared/mac/LayerTreeContextMac.mm:
(WebKit::LayerTreeContext::decode):
* Shared/mac/ObjCObjectGraphCoders.h:
(WebContextObjCObjectGraphDecoder):
(InjectedBundleObjCObjectGraphDecoder):
* Shared/mac/ObjCObjectGraphCoders.mm:
(WebKit::ObjCObjectGraphDecoder::baseDecode):
(WebKit::WebContextObjCObjectGraphDecoderImpl::decode):
(WebKit::InjectedBundleObjCObjectGraphDecoderImpl::decode):
(WebKit::WebContextObjCObjectGraphDecoder::decode):
(WebKit::InjectedBundleObjCObjectGraphDecoder::decode):
* Shared/mac/PlatformCertificateInfo.h:
(PlatformCertificateInfo):
* Shared/mac/PlatformCertificateInfo.mm:
(WebKit::PlatformCertificateInfo::decode):
* Shared/mac/RemoteLayerTreeTransaction.h:
(LayerProperties):
(RemoteLayerTreeTransaction):
* Shared/mac/RemoteLayerTreeTransaction.mm:
(WebKit::RemoteLayerTreeTransaction::LayerProperties::decode):
(WebKit::RemoteLayerTreeTransaction::decode):
* Shared/mac/SandboxExtensionMac.mm:
(WebKit::SandboxExtension::Handle::decode):
(WebKit::SandboxExtension::HandleArray::decode):
* Shared/mac/SecItemRequestData.cpp:
(WebKit::SecItemRequestData::decode):
* Shared/mac/SecItemRequestData.h:
* Shared/mac/SecItemResponseData.cpp:
(WebKit::SecItemResponseData::decode):
* Shared/mac/SecItemResponseData.h:
(SecItemResponseData):
* Shared/mac/WebCoreArgumentCodersMac.mm:
(CoreIPC::::decodePlatformData):
(CoreIPC::::decode):
* UIProcess/WebContextUserMessageCoders.h:
(WebKit::WebContextUserMessageDecoder::decode):
* WebProcess/InjectedBundle/InjectedBundleUserMessageCoders.h:
(WebKit::InjectedBundleUserMessageDecoder::decode):
* WebProcess/Plugins/Plugin.cpp:
(WebKit::Plugin::Parameters::decode):
* WebProcess/Plugins/Plugin.h:
(Parameters):

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

109 files changed:
Source/WebKit2/ChangeLog
Source/WebKit2/Platform/CoreIPC/ArgumentCoder.h
Source/WebKit2/Platform/CoreIPC/ArgumentCoders.cpp
Source/WebKit2/Platform/CoreIPC/ArgumentCoders.h
Source/WebKit2/Platform/CoreIPC/ArgumentDecoder.h
Source/WebKit2/Platform/CoreIPC/Arguments.h
Source/WebKit2/Platform/CoreIPC/Attachment.cpp
Source/WebKit2/Platform/CoreIPC/Attachment.h
Source/WebKit2/Platform/CoreIPC/DataReference.cpp
Source/WebKit2/Platform/CoreIPC/DataReference.h
Source/WebKit2/Platform/CoreIPC/StringReference.cpp
Source/WebKit2/Platform/CoreIPC/StringReference.h
Source/WebKit2/Platform/CoreIPC/mac/MachPort.h
Source/WebKit2/Platform/SharedMemory.h
Source/WebKit2/Platform/mac/SharedMemoryMac.cpp
Source/WebKit2/PluginProcess/PluginCreationParameters.cpp
Source/WebKit2/PluginProcess/PluginCreationParameters.h
Source/WebKit2/Shared/DictionaryPopupInfo.cpp
Source/WebKit2/Shared/DictionaryPopupInfo.h
Source/WebKit2/Shared/EditorState.cpp
Source/WebKit2/Shared/EditorState.h
Source/WebKit2/Shared/FontInfo.cpp
Source/WebKit2/Shared/FontInfo.h
Source/WebKit2/Shared/LayerTreeContext.h
Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.cpp
Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.h
Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.cpp
Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.h
Source/WebKit2/Shared/OriginAndDatabases.cpp
Source/WebKit2/Shared/OriginAndDatabases.h
Source/WebKit2/Shared/PlatformPopupMenuData.cpp
Source/WebKit2/Shared/PlatformPopupMenuData.h
Source/WebKit2/Shared/Plugins/NPIdentifierData.cpp
Source/WebKit2/Shared/Plugins/NPIdentifierData.h
Source/WebKit2/Shared/Plugins/NPVariantData.cpp
Source/WebKit2/Shared/Plugins/NPVariantData.h
Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.cpp
Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.h
Source/WebKit2/Shared/PrintInfo.cpp
Source/WebKit2/Shared/PrintInfo.h
Source/WebKit2/Shared/SandboxExtension.h
Source/WebKit2/Shared/SecurityOriginData.cpp
Source/WebKit2/Shared/SecurityOriginData.h
Source/WebKit2/Shared/SessionState.cpp
Source/WebKit2/Shared/SessionState.h
Source/WebKit2/Shared/ShareableBitmap.cpp
Source/WebKit2/Shared/ShareableBitmap.h
Source/WebKit2/Shared/ShareableResource.cpp
Source/WebKit2/Shared/ShareableResource.h
Source/WebKit2/Shared/SharedWorkerProcessCreationParameters.cpp
Source/WebKit2/Shared/SharedWorkerProcessCreationParameters.h
Source/WebKit2/Shared/StatisticsData.cpp
Source/WebKit2/Shared/StatisticsData.h
Source/WebKit2/Shared/StringPairVector.h
Source/WebKit2/Shared/UpdateInfo.cpp
Source/WebKit2/Shared/UpdateInfo.h
Source/WebKit2/Shared/UserMessageCoders.h
Source/WebKit2/Shared/WebContextMenuItemData.cpp
Source/WebKit2/Shared/WebContextMenuItemData.h
Source/WebKit2/Shared/WebCoreArgumentCoders.cpp
Source/WebKit2/Shared/WebCoreArgumentCoders.h
Source/WebKit2/Shared/WebEvent.cpp
Source/WebKit2/Shared/WebEvent.h
Source/WebKit2/Shared/WebGeolocationPosition.cpp
Source/WebKit2/Shared/WebGeolocationPosition.h
Source/WebKit2/Shared/WebGestureEvent.cpp
Source/WebKit2/Shared/WebHitTestResult.cpp
Source/WebKit2/Shared/WebHitTestResult.h
Source/WebKit2/Shared/WebKeyboardEvent.cpp
Source/WebKit2/Shared/WebMouseEvent.cpp
Source/WebKit2/Shared/WebNavigationDataStore.h
Source/WebKit2/Shared/WebPageCreationParameters.cpp
Source/WebKit2/Shared/WebPageCreationParameters.h
Source/WebKit2/Shared/WebPageGroupData.cpp
Source/WebKit2/Shared/WebPageGroupData.h
Source/WebKit2/Shared/WebPlatformTouchPoint.cpp
Source/WebKit2/Shared/WebPopupItem.cpp
Source/WebKit2/Shared/WebPopupItem.h
Source/WebKit2/Shared/WebPreferencesStore.cpp
Source/WebKit2/Shared/WebPreferencesStore.h
Source/WebKit2/Shared/WebProcessCreationParameters.cpp
Source/WebKit2/Shared/WebProcessCreationParameters.h
Source/WebKit2/Shared/WebTouchEvent.cpp
Source/WebKit2/Shared/WebWheelEvent.cpp
Source/WebKit2/Shared/cf/ArgumentCodersCF.cpp
Source/WebKit2/Shared/cf/ArgumentCodersCF.h
Source/WebKit2/Shared/mac/ArgumentCodersMac.h
Source/WebKit2/Shared/mac/ArgumentCodersMac.mm
Source/WebKit2/Shared/mac/AttributedString.h
Source/WebKit2/Shared/mac/AttributedString.mm
Source/WebKit2/Shared/mac/ColorSpaceData.h
Source/WebKit2/Shared/mac/ColorSpaceData.mm
Source/WebKit2/Shared/mac/LayerTreeContextMac.mm
Source/WebKit2/Shared/mac/ObjCObjectGraphCoders.h
Source/WebKit2/Shared/mac/ObjCObjectGraphCoders.mm
Source/WebKit2/Shared/mac/PlatformCertificateInfo.h
Source/WebKit2/Shared/mac/PlatformCertificateInfo.mm
Source/WebKit2/Shared/mac/RemoteLayerTreeTransaction.h
Source/WebKit2/Shared/mac/RemoteLayerTreeTransaction.mm
Source/WebKit2/Shared/mac/SandboxExtensionMac.mm
Source/WebKit2/Shared/mac/SecItemRequestData.cpp
Source/WebKit2/Shared/mac/SecItemRequestData.h
Source/WebKit2/Shared/mac/SecItemResponseData.cpp
Source/WebKit2/Shared/mac/SecItemResponseData.h
Source/WebKit2/Shared/mac/WebCoreArgumentCodersMac.mm
Source/WebKit2/UIProcess/WebContextUserMessageCoders.h
Source/WebKit2/WebProcess/InjectedBundle/InjectedBundleUserMessageCoders.h
Source/WebKit2/WebProcess/Plugins/Plugin.cpp
Source/WebKit2/WebProcess/Plugins/Plugin.h

index 44db53b..f9754d7 100644 (file)
@@ -1,3 +1,256 @@
+2013-02-01  Anders Carlsson  <andersca@apple.com>
+
+        Message decoding functions should take a MessageDecoder reference
+        https://bugs.webkit.org/show_bug.cgi?id=108669
+
+        Reviewed by Andreas Kling.
+
+        Message encoding functions already take a reference instead of a pointer, so
+        make the decoding functions take a reference as well.
+
+        * Platform/CoreIPC/ArgumentCoder.h:
+        (CoreIPC::ArgumentCoder::decode):
+        * Platform/CoreIPC/ArgumentCoders.cpp:
+        (CoreIPC::::decode):
+        (CoreIPC::decodeStringText):
+        * Platform/CoreIPC/ArgumentCoders.h:
+        (CoreIPC::SimpleArgumentCoder::decode):
+        * Platform/CoreIPC/ArgumentDecoder.h:
+        (CoreIPC::ArgumentDecoder::decode):
+        * Platform/CoreIPC/Arguments.h:
+        (CoreIPC::Arguments0::decode):
+        (CoreIPC::Arguments1::decode):
+        (CoreIPC::Arguments2::decode):
+        (CoreIPC::Arguments3::decode):
+        (CoreIPC::Arguments4::decode):
+        (CoreIPC::Arguments5::decode):
+        (CoreIPC::Arguments6::decode):
+        (CoreIPC::Arguments7::decode):
+        (CoreIPC::Arguments8::decode):
+        (CoreIPC::Arguments10::decode):
+        * Platform/CoreIPC/Attachment.cpp:
+        (CoreIPC::Attachment::decode):
+        * Platform/CoreIPC/Attachment.h:
+        (Attachment):
+        * Platform/CoreIPC/DataReference.cpp:
+        (CoreIPC::DataReference::decode):
+        * Platform/CoreIPC/DataReference.h:
+        (DataReference):
+        * Platform/CoreIPC/StringReference.cpp:
+        (CoreIPC::StringReference::decode):
+        * Platform/CoreIPC/StringReference.h:
+        (StringReference):
+        * Platform/CoreIPC/mac/MachPort.h:
+        (CoreIPC::MachPort::decode):
+        * Platform/SharedMemory.h:
+        (Handle):
+        * Platform/mac/SharedMemoryMac.cpp:
+        (WebKit::SharedMemory::Handle::decode):
+        * PluginProcess/PluginCreationParameters.cpp:
+        (WebKit::PluginCreationParameters::decode):
+        * PluginProcess/PluginCreationParameters.h:
+        (PluginCreationParameters):
+        * Shared/DictionaryPopupInfo.cpp:
+        (WebKit::DictionaryPopupInfo::decode):
+        * Shared/DictionaryPopupInfo.h:
+        (DictionaryPopupInfo):
+        * Shared/EditorState.cpp:
+        (WebKit::EditorState::decode):
+        * Shared/EditorState.h:
+        (EditorState):
+        * Shared/FontInfo.cpp:
+        (WebKit::FontInfo::decode):
+        * Shared/FontInfo.h:
+        (FontInfo):
+        * Shared/LayerTreeContext.h:
+        (LayerTreeContext):
+        * Shared/Network/NetworkProcessCreationParameters.cpp:
+        (WebKit::NetworkProcessCreationParameters::decode):
+        * Shared/Network/NetworkProcessCreationParameters.h:
+        (NetworkProcessCreationParameters):
+        * Shared/Network/NetworkResourceLoadParameters.cpp:
+        (WebKit::NetworkResourceLoadParameters::decode):
+        * Shared/Network/NetworkResourceLoadParameters.h:
+        (NetworkResourceLoadParameters):
+        * Shared/OriginAndDatabases.cpp:
+        (WebKit::OriginAndDatabases::decode):
+        * Shared/OriginAndDatabases.h:
+        (OriginAndDatabases):
+        * Shared/PlatformPopupMenuData.cpp:
+        (WebKit::PlatformPopupMenuData::decode):
+        * Shared/PlatformPopupMenuData.h:
+        (PlatformPopupMenuData):
+        * Shared/Plugins/NPIdentifierData.cpp:
+        (WebKit::NPIdentifierData::decode):
+        * Shared/Plugins/NPIdentifierData.h:
+        (NPIdentifierData):
+        * Shared/Plugins/NPVariantData.cpp:
+        (WebKit::NPVariantData::decode):
+        * Shared/Plugins/NPVariantData.h:
+        (NPVariantData):
+        * Shared/Plugins/PluginProcessCreationParameters.cpp:
+        (WebKit::PluginProcessCreationParameters::decode):
+        * Shared/Plugins/PluginProcessCreationParameters.h:
+        (PluginProcessCreationParameters):
+        * Shared/PrintInfo.cpp:
+        (WebKit::PrintInfo::decode):
+        * Shared/PrintInfo.h:
+        (PrintInfo):
+        * Shared/SandboxExtension.h:
+        (Handle):
+        (HandleArray):
+        (WebKit::SandboxExtension::Handle::decode):
+        (WebKit::SandboxExtension::HandleArray::decode):
+        * Shared/SecurityOriginData.cpp:
+        (WebKit::SecurityOriginData::decode):
+        * Shared/SecurityOriginData.h:
+        (SecurityOriginData):
+        * Shared/SessionState.cpp:
+        (WebKit::SessionState::decode):
+        * Shared/SessionState.h:
+        (SessionState):
+        * Shared/ShareableBitmap.cpp:
+        (WebKit::ShareableBitmap::Handle::decode):
+        * Shared/ShareableBitmap.h:
+        (Handle):
+        * Shared/ShareableResource.cpp:
+        (WebKit::ShareableResource::Handle::decode):
+        * Shared/ShareableResource.h:
+        (Handle):
+        * Shared/SharedWorkerProcessCreationParameters.cpp:
+        (WebKit::SharedWorkerProcessCreationParameters::decode):
+        * Shared/SharedWorkerProcessCreationParameters.h:
+        (SharedWorkerProcessCreationParameters):
+        * Shared/StatisticsData.cpp:
+        (WebKit::StatisticsData::decode):
+        * Shared/StatisticsData.h:
+        (StatisticsData):
+        * Shared/StringPairVector.h:
+        (WebKit::StringPairVector::decode):
+        * Shared/UpdateInfo.cpp:
+        (WebKit::UpdateInfo::decode):
+        * Shared/UpdateInfo.h:
+        (UpdateInfo):
+        * Shared/UserMessageCoders.h:
+        (WebKit::UserMessageDecoder::baseDecode):
+        * Shared/WebContextMenuItemData.cpp:
+        (WebKit::WebContextMenuItemData::decode):
+        * Shared/WebContextMenuItemData.h:
+        (WebContextMenuItemData):
+        * Shared/WebCoreArgumentCoders.cpp:
+        (CoreIPC::::decode):
+        (CoreIPC::decodeImage):
+        * Shared/WebCoreArgumentCoders.h:
+        * Shared/WebEvent.cpp:
+        (WebKit::WebEvent::decode):
+        * Shared/WebEvent.h:
+        (WebEvent):
+        (WebMouseEvent):
+        (WebWheelEvent):
+        (WebKeyboardEvent):
+        (WebGestureEvent):
+        (WebPlatformTouchPoint):
+        (WebTouchEvent):
+        * Shared/WebGeolocationPosition.cpp:
+        (WebKit::WebGeolocationPosition::Data::decode):
+        * Shared/WebGeolocationPosition.h:
+        (Data):
+        * Shared/WebGestureEvent.cpp:
+        (WebKit::WebGestureEvent::decode):
+        * Shared/WebHitTestResult.cpp:
+        (WebKit::WebHitTestResult::Data::decode):
+        * Shared/WebHitTestResult.h:
+        (Data):
+        * Shared/WebKeyboardEvent.cpp:
+        (WebKit::WebKeyboardEvent::decode):
+        * Shared/WebMouseEvent.cpp:
+        (WebKit::WebMouseEvent::decode):
+        * Shared/WebNavigationDataStore.h:
+        (WebKit::WebNavigationDataStore::decode):
+        * Shared/WebPageCreationParameters.cpp:
+        (WebKit::WebPageCreationParameters::decode):
+        * Shared/WebPageCreationParameters.h:
+        (WebPageCreationParameters):
+        * Shared/WebPageGroupData.cpp:
+        (WebKit::WebPageGroupData::decode):
+        * Shared/WebPageGroupData.h:
+        (WebPageGroupData):
+        * Shared/WebPlatformTouchPoint.cpp:
+        (WebKit::WebPlatformTouchPoint::decode):
+        * Shared/WebPopupItem.cpp:
+        (WebKit::WebPopupItem::decode):
+        * Shared/WebPopupItem.h:
+        * Shared/WebPreferencesStore.cpp:
+        (WebKit::WebPreferencesStore::decode):
+        * Shared/WebPreferencesStore.h:
+        (WebPreferencesStore):
+        * Shared/WebProcessCreationParameters.cpp:
+        (WebKit::WebProcessCreationParameters::decode):
+        * Shared/WebProcessCreationParameters.h:
+        (WebProcessCreationParameters):
+        * Shared/WebTouchEvent.cpp:
+        (WebKit::WebTouchEvent::decode):
+        * Shared/WebWheelEvent.cpp:
+        (WebKit::WebWheelEvent::decode):
+        * Shared/cf/ArgumentCodersCF.cpp:
+        (CoreIPC::decode):
+        * Shared/cf/ArgumentCodersCF.h:
+        (CoreIPC):
+        * Shared/mac/ArgumentCodersMac.h:
+        (CoreIPC):
+        * Shared/mac/ArgumentCodersMac.mm:
+        (CoreIPC::decode):
+        * Shared/mac/AttributedString.h:
+        (AttributedString):
+        * Shared/mac/AttributedString.mm:
+        (WebKit::AttributedString::decode):
+        * Shared/mac/ColorSpaceData.h:
+        (ColorSpaceData):
+        * Shared/mac/ColorSpaceData.mm:
+        (WebKit::ColorSpaceData::decode):
+        * Shared/mac/LayerTreeContextMac.mm:
+        (WebKit::LayerTreeContext::decode):
+        * Shared/mac/ObjCObjectGraphCoders.h:
+        (WebContextObjCObjectGraphDecoder):
+        (InjectedBundleObjCObjectGraphDecoder):
+        * Shared/mac/ObjCObjectGraphCoders.mm:
+        (WebKit::ObjCObjectGraphDecoder::baseDecode):
+        (WebKit::WebContextObjCObjectGraphDecoderImpl::decode):
+        (WebKit::InjectedBundleObjCObjectGraphDecoderImpl::decode):
+        (WebKit::WebContextObjCObjectGraphDecoder::decode):
+        (WebKit::InjectedBundleObjCObjectGraphDecoder::decode):
+        * Shared/mac/PlatformCertificateInfo.h:
+        (PlatformCertificateInfo):
+        * Shared/mac/PlatformCertificateInfo.mm:
+        (WebKit::PlatformCertificateInfo::decode):
+        * Shared/mac/RemoteLayerTreeTransaction.h:
+        (LayerProperties):
+        (RemoteLayerTreeTransaction):
+        * Shared/mac/RemoteLayerTreeTransaction.mm:
+        (WebKit::RemoteLayerTreeTransaction::LayerProperties::decode):
+        (WebKit::RemoteLayerTreeTransaction::decode):
+        * Shared/mac/SandboxExtensionMac.mm:
+        (WebKit::SandboxExtension::Handle::decode):
+        (WebKit::SandboxExtension::HandleArray::decode):
+        * Shared/mac/SecItemRequestData.cpp:
+        (WebKit::SecItemRequestData::decode):
+        * Shared/mac/SecItemRequestData.h:
+        * Shared/mac/SecItemResponseData.cpp:
+        (WebKit::SecItemResponseData::decode):
+        * Shared/mac/SecItemResponseData.h:
+        (SecItemResponseData):
+        * Shared/mac/WebCoreArgumentCodersMac.mm:
+        (CoreIPC::::decodePlatformData):
+        (CoreIPC::::decode):
+        * UIProcess/WebContextUserMessageCoders.h:
+        (WebKit::WebContextUserMessageDecoder::decode):
+        * WebProcess/InjectedBundle/InjectedBundleUserMessageCoders.h:
+        (WebKit::InjectedBundleUserMessageDecoder::decode):
+        * WebProcess/Plugins/Plugin.cpp:
+        (WebKit::Plugin::Parameters::decode):
+        * WebProcess/Plugins/Plugin.h:
+        (Parameters):
+
 2013-02-01  Carlos Garcia Campos  <cgarcia@igalia.com>
 
         [GTK] Adapt WorkQueueGtk to the latest changes in WebKit2 after r141497
index 4baab9f..8cc3738 100644 (file)
@@ -39,7 +39,7 @@ template<typename T> struct ArgumentCoder {
         t.encode(encoder);
     }
 
-    static bool decode(ArgumentDecoder* decoder, T& t)
+    static bool decode(ArgumentDecoder& decoder, T& t)
     {
         return T::decode(decoder, t);
     }
index 4bb6185..0114a8a 100644 (file)
@@ -37,10 +37,10 @@ void ArgumentCoder<AtomicString>::encode(ArgumentEncoder& encoder, const AtomicS
     encoder << atomicString.string();
 }
 
-bool ArgumentCoder<AtomicString>::decode(ArgumentDecoder* decoder, AtomicString& atomicString)
+bool ArgumentCoder<AtomicString>::decode(ArgumentDecoder& decoder, AtomicString& atomicString)
 {
     String string;
-    if (!decoder->decode(string))
+    if (!decoder.decode(string))
         return false;
 
     atomicString = string;
@@ -60,10 +60,10 @@ void ArgumentCoder<CString>::encode(ArgumentEncoder& encoder, const CString& str
     encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length, 1);
 }
 
-bool ArgumentCoder<CString>::decode(ArgumentDecoder* decoder, CString& result)
+bool ArgumentCoder<CString>::decode(ArgumentDecoder& decoder, CString& result)
 {
     uint32_t length;
-    if (!decoder->decode(length))
+    if (!decoder.decode(length))
         return false;
 
     if (length == std::numeric_limits<uint32_t>::max()) {
@@ -73,14 +73,14 @@ bool ArgumentCoder<CString>::decode(ArgumentDecoder* decoder, CString& result)
     }
 
     // Before allocating the string, make sure that the decoder buffer is big enough.
-    if (!decoder->bufferIsLargeEnoughToContain<char>(length)) {
-        decoder->markInvalid();
+    if (!decoder.bufferIsLargeEnoughToContain<char>(length)) {
+        decoder.markInvalid();
         return false;
     }
 
     char* buffer;
     CString string = CString::newUninitialized(length, buffer);
-    if (!decoder->decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length, 1))
+    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length, 1))
         return false;
 
     result = string;
@@ -108,27 +108,27 @@ void ArgumentCoder<String>::encode(ArgumentEncoder& encoder, const String& strin
 }
 
 template <typename CharacterType>
-static inline bool decodeStringText(ArgumentDecoder* decoder, uint32_t length, String& result)
+static inline bool decodeStringText(ArgumentDecoder& decoder, uint32_t length, String& result)
 {
     // Before allocating the string, make sure that the decoder buffer is big enough.
-    if (!decoder->bufferIsLargeEnoughToContain<CharacterType>(length)) {
-        decoder->markInvalid();
+    if (!decoder.bufferIsLargeEnoughToContain<CharacterType>(length)) {
+        decoder.markInvalid();
         return false;
     }
     
     CharacterType* buffer;
     String string = String::createUninitialized(length, buffer);
-    if (!decoder->decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(CharacterType), __alignof(CharacterType)))
+    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(CharacterType), __alignof(CharacterType)))
         return false;
     
     result = string;
     return true;    
 }
 
-bool ArgumentCoder<String>::decode(ArgumentDecoder* decoder, String& result)
+bool ArgumentCoder<String>::decode(ArgumentDecoder& decoder, String& result)
 {
     uint32_t length;
-    if (!decoder->decode(length))
+    if (!decoder.decode(length))
         return false;
 
     if (length == std::numeric_limits<uint32_t>::max()) {
@@ -139,7 +139,7 @@ bool ArgumentCoder<String>::decode(ArgumentDecoder* decoder, String& result)
 
     bool is8Bit;
 
-    if (!decoder->decode(is8Bit))
+    if (!decoder.decode(is8Bit))
         return false;
 
     if (is8Bit)
index f4658a9..6c8241e 100644 (file)
@@ -43,9 +43,9 @@ template<typename T> struct SimpleArgumentCoder {
         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(&t), sizeof(T), __alignof(T));
     }
 
-    static bool decode(ArgumentDecoder* decoder, T& t)
+    static bool decode(ArgumentDecoder& decoder, T& t)
     {
-        return decoder->decodeFixedLengthData(reinterpret_cast<uint8_t*>(&t), sizeof(T), __alignof(T));
+        return decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(&t), sizeof(T), __alignof(T));
     }
 };
 
@@ -55,14 +55,14 @@ template<typename T, typename U> struct ArgumentCoder<std::pair<T, U> > {
         encoder << pair.first << pair.second;
     }
 
-    static bool decode(ArgumentDecoder* decoder, std::pair<T, U>& pair)
+    static bool decode(ArgumentDecoder& decoder, std::pair<T, U>& pair)
     {
         T first;
-        if (!decoder->decode(first))
+        if (!decoder.decode(first))
             return false;
 
         U second;
-        if (!decoder->decode(second))
+        if (!decoder.decode(second))
             return false;
 
         pair.first = first;
@@ -77,14 +77,14 @@ template<typename KeyType, typename ValueType> struct ArgumentCoder<WTF::KeyValu
         encoder << pair.key << pair.value;
     }
 
-    static bool decode(ArgumentDecoder* decoder, WTF::KeyValuePair<KeyType, ValueType>& pair)
+    static bool decode(ArgumentDecoder& decoder, WTF::KeyValuePair<KeyType, ValueType>& pair)
     {
         KeyType key;
-        if (!decoder->decode(key))
+        if (!decoder.decode(key))
             return false;
 
         ValueType value;
-        if (!decoder->decode(value))
+        if (!decoder.decode(value))
             return false;
 
         pair.key = key;
@@ -103,16 +103,16 @@ template<typename T> struct VectorArgumentCoder<false, T> {
             encoder << vector[i];
     }
 
-    static bool decode(ArgumentDecoder* decoder, Vector<T>& vector)
+    static bool decode(ArgumentDecoder& decoder, Vector<T>& vector)
     {
         uint64_t size;
-        if (!decoder->decode(size))
+        if (!decoder.decode(size))
             return false;
 
         Vector<T> tmp;
         for (size_t i = 0; i < size; ++i) {
             T element;
-            if (!decoder->decode(element))
+            if (!decoder.decode(element))
                 return false;
             
             tmp.append(element);
@@ -131,24 +131,24 @@ template<typename T> struct VectorArgumentCoder<true, T> {
         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(vector.data()), vector.size() * sizeof(T), __alignof(T));
     }
     
-    static bool decode(ArgumentDecoder* decoder, Vector<T>& vector)
+    static bool decode(ArgumentDecoder& decoder, Vector<T>& vector)
     {
         uint64_t size;
-        if (!decoder->decode(size))
+        if (!decoder.decode(size))
             return false;
 
         // Since we know the total size of the elements, we can allocate the vector in
         // one fell swoop. Before allocating we must however make sure that the decoder buffer
         // is big enough.
-        if (!decoder->bufferIsLargeEnoughToContain<T>(size)) {
-            decoder->markInvalid();
+        if (!decoder.bufferIsLargeEnoughToContain<T>(size)) {
+            decoder.markInvalid();
             return false;
         }
 
         Vector<T> temp;
         temp.resize(size);
 
-        decoder->decodeFixedLengthData(reinterpret_cast<uint8_t*>(temp.data()), size * sizeof(T), __alignof(T));
+        decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(temp.data()), size * sizeof(T), __alignof(T));
 
         vector.swap(temp);
         return true;
@@ -167,24 +167,24 @@ template<typename KeyArg, typename MappedArg, typename HashArg, typename KeyTrai
             encoder << *it;
     }
 
-    static bool decode(ArgumentDecoder* decoder, HashMapType& hashMap)
+    static bool decode(ArgumentDecoder& decoder, HashMapType& hashMap)
     {
         uint64_t hashMapSize;
-        if (!decoder->decode(hashMapSize))
+        if (!decoder.decode(hashMapSize))
             return false;
 
         HashMapType tempHashMap;
         for (uint64_t i = 0; i < hashMapSize; ++i) {
             KeyArg key;
             MappedArg value;
-            if (!decoder->decode(key))
+            if (!decoder.decode(key))
                 return false;
-            if (!decoder->decode(value))
+            if (!decoder.decode(value))
                 return false;
 
             if (!tempHashMap.add(key, value).isNewEntry) {
                 // The hash map already has the specified key, bail.
-                decoder->markInvalid();
+                decoder.markInvalid();
                 return false;
             }
         }
@@ -196,17 +196,17 @@ template<typename KeyArg, typename MappedArg, typename HashArg, typename KeyTrai
 
 template<> struct ArgumentCoder<AtomicString> {
     static void encode(ArgumentEncoder&, const AtomicString&);
-    static bool decode(ArgumentDecoder*, AtomicString&);
+    static bool decode(ArgumentDecoder&, AtomicString&);
 };
 
 template<> struct ArgumentCoder<CString> {
     static void encode(ArgumentEncoder&, const CString&);
-    static bool decode(ArgumentDecoder*, CString&);
+    static bool decode(ArgumentDecoder&, CString&);
 };
 
 template<> struct ArgumentCoder<String> {
     static void encode(ArgumentEncoder&, const String&);
-    static bool decode(ArgumentDecoder*, String&);
+    static bool decode(ArgumentDecoder&, String&);
 };
 
 } // namespace CoreIPC
index 9a9ed29..21e8358 100644 (file)
@@ -87,7 +87,7 @@ public:
     // Generic type decode function.
     template<typename T> bool decode(T& t)
     {
-        return ArgumentCoder<T>::decode(this, t);
+        return ArgumentCoder<T>::decode(*this, t);
     }
 
     bool removeAttachment(Attachment&);
index 7ed94d8..764c5eb 100644 (file)
@@ -39,7 +39,7 @@ struct Arguments0 {
     {
     }
 
-    static bool decode(ArgumentDecoder*, Arguments0&)
+    static bool decode(ArgumentDecoder&, Arguments0&)
     {
         return true;
     }
@@ -62,9 +62,9 @@ template<typename T1> struct Arguments1 {
         encoder.encode(argument1);
     }
 
-    static bool decode(ArgumentDecoder* decoder, Arguments1& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments1& result)
     {
-        return decoder->decode(result.argument1);
+        return decoder.decode(result.argument1);
     }
     
     T1 argument1;
@@ -90,12 +90,12 @@ template<typename T1, typename T2> struct Arguments2 : Arguments1<T1> {
         encoder.encode(argument2);
     }
 
-    static bool decode(ArgumentDecoder* decoder, Arguments2& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments2& result)
     {
         if (!Arguments1<T1>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.argument2);
+        return decoder.decode(result.argument2);
     }
 
     T2 argument2;
@@ -122,12 +122,12 @@ template<typename T1, typename T2, typename T3> struct Arguments3 : Arguments2<T
         encoder.encode(argument3);
     }
 
-    static bool decode(ArgumentDecoder* decoder, Arguments3& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments3& result)
     {
         if (!Arguments2<T1, T2>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.argument3);
+        return decoder.decode(result.argument3);
     }
 
     T3 argument3;
@@ -155,12 +155,12 @@ template<typename T1, typename T2, typename T3, typename T4> struct Arguments4 :
         encoder.encode(argument4);
     }
     
-    static bool decode(ArgumentDecoder* decoder, Arguments4& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments4& result)
     {
         if (!Arguments3<T1, T2, T3>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.argument4);
+        return decoder.decode(result.argument4);
     }
 
     T4 argument4;
@@ -189,12 +189,12 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5> struct
         encoder.encode(argument5);
     }
     
-    static bool decode(ArgumentDecoder* decoder, Arguments5& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments5& result)
     {
         if (!Arguments4<T1, T2, T3, T4>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.argument5);
+        return decoder.decode(result.argument5);
     }
 
     T5 argument5;
@@ -224,12 +224,12 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
         encoder.encode(argument6);
     }
     
-    static bool decode(ArgumentDecoder* decoder, Arguments6& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments6& result)
     {
         if (!Arguments5<T1, T2, T3, T4, T5>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.argument6);
+        return decoder.decode(result.argument6);
     }
 
     T6 argument6;
@@ -260,12 +260,12 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
         encoder.encode(argument7);
     }
     
-    static bool decode(ArgumentDecoder* decoder, Arguments7& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments7& result)
     {
         if (!Arguments6<T1, T2, T3, T4, T5, T6>::decode(decoder, result))
             return false;
         
-        return decoder->decode(result.argument7);
+        return decoder.decode(result.argument7);
     }
 
     T7 argument7;
@@ -295,12 +295,12 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
         encoder.encode(argument8);
     }
 
-    static bool decode(ArgumentDecoder* decoder, Arguments8& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments8& result)
     {
         if (!Arguments7<T1, T2, T3, T4, T5, T6, T7>::decode(decoder, result))
             return false;
 
-        return decoder->decode(result.argument8);
+        return decoder.decode(result.argument8);
     }
 
     T8 argument8;
@@ -334,13 +334,13 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
         encoder.encode(argument10);
     }
 
-    static bool decode(ArgumentDecoder* decoder, Arguments10& result)
+    static bool decode(ArgumentDecoder& decoder, Arguments10& result)
     {
         if (!Arguments8<T1, T2, T3, T4, T5, T6, T7, T8>::decode(decoder, result))
             return false;
 
-        decoder->decode(result.argument9);
-        return decoder->decode(result.argument10);
+        decoder.decode(result.argument9);
+        return decoder.decode(result.argument10);
     }
 
     T9 argument9;
index 8f47748..5d19bad 100644 (file)
@@ -64,9 +64,9 @@ void Attachment::encode(ArgumentEncoder& encoder) const
     encoder.addAttachment(*this);
 }
 
-bool Attachment::decode(ArgumentDecoder* decoder, Attachment& attachment)
+bool Attachment::decode(ArgumentDecoder& decoder, Attachment& attachment)
 {
-    if (!decoder->removeAttachment(attachment))
+    if (!decoder.removeAttachment(attachment))
         return false;
     return true;
 }
index dd26b3a..a5af559 100644 (file)
@@ -83,7 +83,7 @@ public:
 #endif
 
     void encode(ArgumentEncoder&) const;
-    static bool decode(ArgumentDecoder*, Attachment&);
+    static bool decode(ArgumentDecoder&, Attachment&);
     
 private:
     Type m_type;
index a144986..5e28d90 100644 (file)
@@ -36,9 +36,9 @@ void DataReference::encode(ArgumentEncoder& encoder) const
     encoder.encodeVariableLengthByteArray(*this);
 }
 
-bool DataReference::decode(ArgumentDecoder* decoder, DataReference& dataReference)
+bool DataReference::decode(ArgumentDecoder& decoder, DataReference& dataReference)
 {
-    return decoder->decodeVariableLengthByteArray(dataReference);
+    return decoder.decodeVariableLengthByteArray(dataReference);
 }
 
 } // namespace CoreIPC
index a0ce8c3..e66b7e0 100644 (file)
@@ -73,7 +73,7 @@ public:
     }
 
     void encode(ArgumentEncoder&) const;
-    static bool decode(ArgumentDecoder* decoder, DataReference& dataReference);
+    static bool decode(ArgumentDecoder&, DataReference&);
 
 private:
     const uint8_t* m_data;
index d466f3f..ac72824 100644 (file)
@@ -44,10 +44,10 @@ void StringReference::encode(ArgumentEncoder& encoder) const
     encoder << DataReference(reinterpret_cast<const uint8_t*>(m_data), m_size);
 }
 
-bool StringReference::decode(ArgumentDecoder* decoder, StringReference& result)
+bool StringReference::decode(ArgumentDecoder& decoder, StringReference& result)
 {
     DataReference dataReference;
-    if (!decoder->decode(dataReference))
+    if (!decoder.decode(dataReference))
         return false;
 
     result.m_data = reinterpret_cast<const char*>(dataReference.data());
index 47235c1..1507b25 100644 (file)
@@ -68,7 +68,7 @@ public:
     }
 
     void encode(ArgumentEncoder&) const;
-    static bool decode(ArgumentDecoder*, StringReference&);
+    static bool decode(ArgumentDecoder&, StringReference&);
 
     struct Hash {
         static unsigned hash(const StringReference& a);
index fa4474e..47aceb7 100644 (file)
@@ -51,10 +51,10 @@ public:
         encoder << Attachment(m_port, m_disposition);
     }
 
-    static bool decode(ArgumentDecoder* decoder, MachPort& p)
+    static bool decode(ArgumentDecoder& decoder, MachPort& p)
     {
         Attachment attachment;
-        if (!decoder->decode(attachment))
+        if (!decoder.decode(attachment))
             return false;
         
         p.m_port = attachment.port();
index 46d032a..a67de8d 100644 (file)
@@ -58,7 +58,7 @@ public:
         bool isNull() const;
 
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, Handle&);
+        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
 
 #if USE(UNIX_DOMAIN_SOCKETS)
         CoreIPC::Attachment releaseToAttachment() const;
index f18c534..dc29d61 100644 (file)
@@ -62,17 +62,17 @@ void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
     m_port = MACH_PORT_NULL;
 }
 
-bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)
+bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
 {
     ASSERT(!handle.m_port);
     ASSERT(!handle.m_size);
 
     uint64_t size;
-    if (!decoder->decode(size))
+    if (!decoder.decode(size))
         return false;
 
     CoreIPC::MachPort machPort;
-    if (!decoder->decode(machPort))
+    if (!decoder.decode(machPort))
         return false;
     
     handle.m_size = size;
index 15650fa..409106a 100644 (file)
@@ -61,34 +61,34 @@ void PluginCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool PluginCreationParameters::decode(CoreIPC::ArgumentDecoder* decoder, PluginCreationParameters& result)
+bool PluginCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, PluginCreationParameters& result)
 {
-    if (!decoder->decode(result.pluginInstanceID) || !result.pluginInstanceID)
+    if (!decoder.decode(result.pluginInstanceID) || !result.pluginInstanceID)
         return false;
 
-    if (!decoder->decode(result.windowNPObjectID))
+    if (!decoder.decode(result.windowNPObjectID))
         return false;
 
-    if (!decoder->decode(result.parameters))
+    if (!decoder.decode(result.parameters))
         return false;
 
-    if (!decoder->decode(result.userAgent))
+    if (!decoder.decode(result.userAgent))
         return false;
 
-    if (!decoder->decode(result.contentsScaleFactor))
+    if (!decoder.decode(result.contentsScaleFactor))
         return false;
 
-    if (!decoder->decode(result.isPrivateBrowsingEnabled))
+    if (!decoder.decode(result.isPrivateBrowsingEnabled))
         return false;
 
-    if (!decoder->decode(result.asynchronousCreationIncomplete))
+    if (!decoder.decode(result.asynchronousCreationIncomplete))
         return false;
 
-    if (!decoder->decode(result.artificialPluginInitializationDelayEnabled))
+    if (!decoder.decode(result.artificialPluginInitializationDelayEnabled))
         return false;
 
 #if USE(ACCELERATED_COMPOSITING)
-    if (!decoder->decode(result.isAcceleratedCompositingEnabled))
+    if (!decoder.decode(result.isAcceleratedCompositingEnabled))
         return false;
 #endif
 
index 1387f14..33f384b 100644 (file)
@@ -41,7 +41,7 @@ struct PluginCreationParameters {
     PluginCreationParameters();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, PluginCreationParameters&);
+    static bool decode(CoreIPC::ArgumentDecoder&, PluginCreationParameters&);
 
     // The unique ID of this plug-in instance.
     uint64_t pluginInstanceID;
index c651181..6e582e4 100644 (file)
@@ -47,15 +47,15 @@ void DictionaryPopupInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool DictionaryPopupInfo::decode(CoreIPC::ArgumentDecoder* decoder, DictionaryPopupInfo& result)
+bool DictionaryPopupInfo::decode(CoreIPC::ArgumentDecoder& decoder, DictionaryPopupInfo& result)
 {
-    if (!decoder->decode(result.origin))
+    if (!decoder.decode(result.origin))
         return false;
-    if (!decoder->decodeEnum(result.type))
+    if (!decoder.decodeEnum(result.type))
         return false;
 #if PLATFORM(MAC)
     bool hadOptions;
-    if (!decoder->decode(hadOptions))
+    if (!decoder.decode(hadOptions))
         return false;
     if (hadOptions) {
         if (!CoreIPC::decode(decoder, result.options))
index 35c7cf1..7ac0b04 100644 (file)
@@ -41,7 +41,7 @@ namespace WebKit {
 
 struct DictionaryPopupInfo {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, DictionaryPopupInfo&);
+    static bool decode(CoreIPC::ArgumentDecoder&, DictionaryPopupInfo&);
 
     enum Type {
         ContextMenu,
index c5c68d8..550cc87 100644 (file)
@@ -56,54 +56,54 @@ void EditorState::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool EditorState::decode(CoreIPC::ArgumentDecoder* decoder, EditorState& result)
+bool EditorState::decode(CoreIPC::ArgumentDecoder& decoder, EditorState& result)
 {
-    if (!decoder->decode(result.shouldIgnoreCompositionSelectionChange))
+    if (!decoder.decode(result.shouldIgnoreCompositionSelectionChange))
         return false;
 
-    if (!decoder->decode(result.selectionIsNone))
+    if (!decoder.decode(result.selectionIsNone))
         return false;
 
-    if (!decoder->decode(result.selectionIsRange))
+    if (!decoder.decode(result.selectionIsRange))
         return false;
 
-    if (!decoder->decode(result.isContentEditable))
+    if (!decoder.decode(result.isContentEditable))
         return false;
 
-    if (!decoder->decode(result.isContentRichlyEditable))
+    if (!decoder.decode(result.isContentRichlyEditable))
         return false;
 
-    if (!decoder->decode(result.isInPasswordField))
+    if (!decoder.decode(result.isInPasswordField))
         return false;
 
-    if (!decoder->decode(result.hasComposition))
+    if (!decoder.decode(result.hasComposition))
         return false;
 
 #if PLATFORM(QT)
-    if (!decoder->decode(result.cursorPosition))
+    if (!decoder.decode(result.cursorPosition))
         return false;
 
-    if (!decoder->decode(result.anchorPosition))
+    if (!decoder.decode(result.anchorPosition))
         return false;
 
-    if (!decoder->decode(result.editorRect))
+    if (!decoder.decode(result.editorRect))
         return false;
 
-    if (!decoder->decode(result.compositionRect))
+    if (!decoder.decode(result.compositionRect))
         return false;
 
-    if (!decoder->decode(result.inputMethodHints))
+    if (!decoder.decode(result.inputMethodHints))
         return false;
 
-    if (!decoder->decode(result.selectedText))
+    if (!decoder.decode(result.selectedText))
         return false;
 
-    if (!decoder->decode(result.surroundingText))
+    if (!decoder.decode(result.surroundingText))
         return false;
 #endif
 
 #if PLATFORM(QT) || PLATFORM(GTK)
-    if (!decoder->decode(result.cursorRect))
+    if (!decoder.decode(result.cursorRect))
         return false;
 #endif
 
index 642dea7..fa687bd 100644 (file)
@@ -78,7 +78,7 @@ struct EditorState {
 #endif
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, EditorState&);
+    static bool decode(CoreIPC::ArgumentDecoder&, EditorState&);
 };
 
 }
index 33ed474..ab64598 100644 (file)
@@ -45,11 +45,11 @@ void FontInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool FontInfo::decode(CoreIPC::ArgumentDecoder* decoder, FontInfo& fontInfo)
+bool FontInfo::decode(CoreIPC::ArgumentDecoder& decoder, FontInfo& fontInfo)
 {    
 #if PLATFORM(MAC)
     bool hasFontAttributeDictionary;
-    if (!decoder->decode(hasFontAttributeDictionary))
+    if (!decoder.decode(hasFontAttributeDictionary))
         return false;
 
     if (!hasFontAttributeDictionary)
index ae11d12..e124f25 100644 (file)
@@ -39,7 +39,7 @@ namespace WebKit {
     
 struct FontInfo {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, FontInfo&);
+    static bool decode(CoreIPC::ArgumentDecoder&, FontInfo&);
     
 #if PLATFORM(MAC)
     RetainPtr<CFDictionaryRef> fontAttributeDictionary;
index 1841ce4..9b8c663 100644 (file)
@@ -48,7 +48,7 @@ public:
     ~LayerTreeContext();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, LayerTreeContext&);
+    static bool decode(CoreIPC::ArgumentDecoder&, LayerTreeContext&);
 
     bool isEmpty() const;
 
index cf341bd..74a4c06 100644 (file)
@@ -55,32 +55,32 @@ void NetworkProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder)
 #endif
 }
 
-bool NetworkProcessCreationParameters::decode(CoreIPC::ArgumentDecoder* decoder, NetworkProcessCreationParameters& result)
+bool NetworkProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, NetworkProcessCreationParameters& result)
 {
-    if (!decoder->decode(result.diskCacheDirectory))
+    if (!decoder.decode(result.diskCacheDirectory))
         return false;
-    if (!decoder->decode(result.diskCacheDirectoryExtensionHandle))
+    if (!decoder.decode(result.diskCacheDirectoryExtensionHandle))
         return false;
-    if (!decoder->decode(result.privateBrowsingEnabled))
+    if (!decoder.decode(result.privateBrowsingEnabled))
         return false;
-    if (!decoder->decodeEnum(result.cacheModel))
+    if (!decoder.decodeEnum(result.cacheModel))
         return false;
 #if PLATFORM(MAC)
-    if (!decoder->decode(result.parentProcessName))
+    if (!decoder.decode(result.parentProcessName))
         return false;
-    if (!decoder->decode(result.uiProcessBundleIdentifier))
+    if (!decoder.decode(result.uiProcessBundleIdentifier))
         return false;
-    if (!decoder->decode(result.nsURLCacheMemoryCapacity))
+    if (!decoder.decode(result.nsURLCacheMemoryCapacity))
         return false;
-    if (!decoder->decode(result.nsURLCacheDiskCapacity))
+    if (!decoder.decode(result.nsURLCacheDiskCapacity))
         return false;
 #if ENABLE(CUSTOM_PROTOCOLS)
-    if (!decoder->decode(result.urlSchemesRegisteredForCustomProtocols))
+    if (!decoder.decode(result.urlSchemesRegisteredForCustomProtocols))
         return false;
 #endif
-    if (!decoder->decode(result.httpProxy))
+    if (!decoder.decode(result.httpProxy))
         return false;
-    if (!decoder->decode(result.httpsProxy))
+    if (!decoder.decode(result.httpsProxy))
         return false;
 #endif
 
index 960224b..25c035f 100644 (file)
@@ -44,7 +44,7 @@ struct NetworkProcessCreationParameters {
     NetworkProcessCreationParameters();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, NetworkProcessCreationParameters&);
+    static bool decode(CoreIPC::ArgumentDecoder&, NetworkProcessCreationParameters&);
 
     bool privateBrowsingEnabled;
     CacheModel cacheModel;
index d6f42e9..80738cb 100644 (file)
@@ -105,47 +105,47 @@ void NetworkResourceLoadParameters::encode(CoreIPC::ArgumentEncoder& encoder) co
     encoder.encode(m_inPrivateBrowsingMode);
 }
 
-bool NetworkResourceLoadParameters::decode(CoreIPC::ArgumentDecoder* decoder, NetworkResourceLoadParameters& result)
+bool NetworkResourceLoadParameters::decode(CoreIPC::ArgumentDecoder& decoder, NetworkResourceLoadParameters& result)
 {
-    if (!decoder->decode(result.m_identifier))
+    if (!decoder.decode(result.m_identifier))
         return false;
 
-    if (!decoder->decode(result.m_webPageID))
+    if (!decoder.decode(result.m_webPageID))
         return false;
 
-    if (!decoder->decode(result.m_webFrameID))
+    if (!decoder.decode(result.m_webFrameID))
         return false;
 
-    if (!decoder->decode(result.m_request))
+    if (!decoder.decode(result.m_request))
         return false;
 
     bool hasHTTPBody;
-    if (!decoder->decode(hasHTTPBody))
+    if (!decoder.decode(hasHTTPBody))
         return false;
 
     if (hasHTTPBody) {
         CoreIPC::DataReference formData;
-        if (!decoder->decode(formData))
+        if (!decoder.decode(formData))
             return false;
         DecoderAdapter httpBodyDecoderAdapter(formData.data(), formData.size());
         result.m_request.setHTTPBody(FormData::decode(httpBodyDecoderAdapter));
 
-        if (!decoder->decode(result.m_requestBodySandboxExtensions))
+        if (!decoder.decode(result.m_requestBodySandboxExtensions))
             return false;
     }
 
     if (result.m_request.url().isLocalFile()) {
-        if (!decoder->decode(result.m_resourceSandboxExtension))
+        if (!decoder.decode(result.m_resourceSandboxExtension))
             return false;
     }
 
-    if (!decoder->decodeEnum(result.m_priority))
+    if (!decoder.decodeEnum(result.m_priority))
         return false;
-    if (!decoder->decodeEnum(result.m_contentSniffingPolicy))
+    if (!decoder.decodeEnum(result.m_contentSniffingPolicy))
         return false;
-    if (!decoder->decodeEnum(result.m_allowStoredCredentials))
+    if (!decoder.decodeEnum(result.m_allowStoredCredentials))
         return false;
-    if (!decoder->decode(result.m_inPrivateBrowsingMode))
+    if (!decoder.decode(result.m_inPrivateBrowsingMode))
         return false;
 
     return true;
index fc2db19..56442d6 100644 (file)
@@ -48,7 +48,7 @@ public:
     NetworkResourceLoadParameters(ResourceLoadIdentifier, uint64_t webPageID, uint64_t webFrameID, const WebCore::ResourceRequest&, WebCore::ResourceLoadPriority, WebCore::ContentSniffingPolicy, WebCore::StoredCredentials, bool inPrivateBrowsingMode);
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, NetworkResourceLoadParameters&);
+    static bool decode(CoreIPC::ArgumentDecoder&, NetworkResourceLoadParameters&);
 
     ResourceLoadIdentifier identifier() const { return m_identifier; }
     uint64_t webPageID() const { return m_webPageID; }
index 5d86c2b..4745b9c 100644 (file)
@@ -42,15 +42,15 @@ void OriginAndDatabases::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << databases;
 }
 
-bool OriginAndDatabases::decode(CoreIPC::ArgumentDecoder* decoder, OriginAndDatabases& originAndDatabases)
+bool OriginAndDatabases::decode(CoreIPC::ArgumentDecoder& decoder, OriginAndDatabases& originAndDatabases)
 {
-    if (!decoder->decode(originAndDatabases.originIdentifier))
+    if (!decoder.decode(originAndDatabases.originIdentifier))
         return false;
-    if (!decoder->decode(originAndDatabases.originQuota))
+    if (!decoder.decode(originAndDatabases.originQuota))
         return false;
-    if (!decoder->decode(originAndDatabases.originUsage))
+    if (!decoder.decode(originAndDatabases.originUsage))
         return false;
-    if (!decoder->decode(originAndDatabases.databases))
+    if (!decoder.decode(originAndDatabases.databases))
         return false;
 
     return true;
index ec064f9..b7b389a 100644 (file)
@@ -41,7 +41,7 @@ namespace WebKit {
 
 struct OriginAndDatabases {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, OriginAndDatabases&);
+    static bool decode(CoreIPC::ArgumentDecoder&, OriginAndDatabases&);
 
     String originIdentifier;
     uint64_t originQuota;
index 80fd2f9..67488ea 100644 (file)
@@ -49,15 +49,15 @@ void PlatformPopupMenuData::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool PlatformPopupMenuData::decode(CoreIPC::ArgumentDecoder* decoder, PlatformPopupMenuData& data)
+bool PlatformPopupMenuData::decode(CoreIPC::ArgumentDecoder& decoder, PlatformPopupMenuData& data)
 {
 #if PLATFORM(MAC)
-    if (!decoder->decode(data.fontInfo))
+    if (!decoder.decode(data.fontInfo))
         return false;
-    if (!decoder->decode(data.shouldPopOver))
+    if (!decoder.decode(data.shouldPopOver))
         return false;
 #elif PLATFORM(QT)
-    if (!decoder->decode(data.multipleSelections))
+    if (!decoder.decode(data.multipleSelections))
         return false;
 #else
     UNUSED_PARAM(decoder);
index a6c885e..70b3f87 100644 (file)
@@ -41,7 +41,7 @@ struct PlatformPopupMenuData {
     PlatformPopupMenuData();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, PlatformPopupMenuData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, PlatformPopupMenuData&);
 
 #if PLATFORM(MAC)
     FontInfo fontInfo;
index a297bc4..2822a60 100644 (file)
@@ -76,15 +76,15 @@ void NPIdentifierData::encode(CoreIPC::ArgumentEncoder& encoder) const
         encoder << m_number;
 }
 
-bool NPIdentifierData::decode(CoreIPC::ArgumentDecoder* decoder, NPIdentifierData& result)
+bool NPIdentifierData::decode(CoreIPC::ArgumentDecoder& decoder, NPIdentifierData& result)
 {
-    if (!decoder->decode(result.m_isString))
+    if (!decoder.decode(result.m_isString))
         return false;
         
     if (result.m_isString)
-        return decoder->decode(result.m_string);
+        return decoder.decode(result.m_string);
 
-    return decoder->decode(result.m_number);
+    return decoder.decode(result.m_number);
 }
 
 } // namespace WebKit
index 56d57fc..fc0e67d 100644 (file)
@@ -48,7 +48,7 @@ public:
     NPIdentifier createNPIdentifier() const;
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, NPIdentifierData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, NPIdentifierData&);
 
 private:
     bool m_isString;
index db96dc7..4cef1cb 100644 (file)
@@ -147,10 +147,10 @@ void NPVariantData::encode(CoreIPC::ArgumentEncoder& encoder) const
     }
 }
 
-bool NPVariantData::decode(CoreIPC::ArgumentDecoder* decoder, NPVariantData& result)
+bool NPVariantData::decode(CoreIPC::ArgumentDecoder& decoder, NPVariantData& result)
 {
     uint32_t type;
-    if (!decoder->decode(type))
+    if (!decoder.decode(type))
         return false;
 
     // We special-case LocalNPObjectID and RemoteNPObjectID here so a LocalNPObjectID is
@@ -169,17 +169,17 @@ bool NPVariantData::decode(CoreIPC::ArgumentDecoder* decoder, NPVariantData& res
     case NPVariantData::Null:
         return true;
     case NPVariantData::Bool:
-        return decoder->decode(result.m_boolValue);
+        return decoder.decode(result.m_boolValue);
     case NPVariantData::Int32:
-        return decoder->decode(result.m_int32Value);
+        return decoder.decode(result.m_int32Value);
     case NPVariantData::Double:
-        return decoder->decode(result.m_doubleValue);
+        return decoder.decode(result.m_doubleValue);
     case NPVariantData::String:
-        return decoder->decode(result.m_stringValue);
+        return decoder.decode(result.m_stringValue);
     case NPVariantData::LocalNPObjectID:
-        return decoder->decode(result.m_localNPObjectIDValue);
+        return decoder.decode(result.m_localNPObjectIDValue);
     case NPVariantData::RemoteNPObjectID:
-        return decoder->decode(result.m_remoteNPObjectIDValue);
+        return decoder.decode(result.m_remoteNPObjectIDValue);
     }
 
     return false;
index a232046..5109958 100644 (file)
@@ -101,7 +101,7 @@ public:
     }
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, NPVariantData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, NPVariantData&);
 
 private:
     uint32_t m_type;
index e11fc8d..0d059a2 100644 (file)
@@ -48,18 +48,18 @@ void PluginProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder)
 #endif
 }
 
-bool PluginProcessCreationParameters::decode(CoreIPC::ArgumentDecoder* decoder, PluginProcessCreationParameters& result)
+bool PluginProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, PluginProcessCreationParameters& result)
 {
-    if (!decoder->decodeEnum(result.processType))
+    if (!decoder.decodeEnum(result.processType))
         return false;
-    if (!decoder->decode(result.supportsAsynchronousPluginInitialization))
+    if (!decoder.decode(result.supportsAsynchronousPluginInitialization))
         return false;
-    if (!decoder->decode(result.minimumLifetime))
+    if (!decoder.decode(result.minimumLifetime))
         return false;
-    if (!decoder->decode(result.terminationTimeout))
+    if (!decoder.decode(result.terminationTimeout))
         return false;
 #if PLATFORM(MAC)
-    if (!decoder->decode(result.acceleratedCompositingPort))
+    if (!decoder.decode(result.acceleratedCompositingPort))
         return false;
 #endif
 
index 36181e2..e827ae4 100644 (file)
@@ -45,7 +45,7 @@ struct PluginProcessCreationParameters {
     PluginProcessCreationParameters();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, PluginProcessCreationParameters&);
+    static bool decode(CoreIPC::ArgumentDecoder&, PluginProcessCreationParameters&);
 
     PluginProcess::Type processType;
     bool supportsAsynchronousPluginInitialization;
index faf008c..734b065 100644 (file)
@@ -55,13 +55,13 @@ void PrintInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool PrintInfo::decode(CoreIPC::ArgumentDecoder* decoder, PrintInfo& info)
+bool PrintInfo::decode(CoreIPC::ArgumentDecoder& decoder, PrintInfo& info)
 {
-    if (!decoder->decode(info.pageSetupScaleFactor))
+    if (!decoder.decode(info.pageSetupScaleFactor))
         return false;
-    if (!decoder->decode(info.availablePaperWidth))
+    if (!decoder.decode(info.availablePaperWidth))
         return false;
-    if (!decoder->decode(info.availablePaperHeight))
+    if (!decoder.decode(info.availablePaperHeight))
         return false;
 
 #if PLATFORM(GTK)
index 97faceb..e801b8d 100644 (file)
@@ -64,7 +64,7 @@ struct PrintInfo {
 #endif
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, PrintInfo&);
+    static bool decode(CoreIPC::ArgumentDecoder&, PrintInfo&);
 };
 
 }
index 027876d..8c9398e 100644 (file)
@@ -58,7 +58,7 @@ public:
         ~Handle();
 
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, Handle&);
+        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
 
     private:
         friend class SandboxExtension;
@@ -78,7 +78,7 @@ public:
         const Handle& operator[](size_t i) const;
         size_t size() const;
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, HandleArray&);
+        static bool decode(CoreIPC::ArgumentDecoder&, HandleArray&);
        
     private:
 #if ENABLE(WEB_PROCESS_SANDBOX)
@@ -114,7 +114,7 @@ private:
 inline SandboxExtension::Handle::Handle() { }
 inline SandboxExtension::Handle::~Handle() { }
 inline void SandboxExtension::Handle::encode(CoreIPC::ArgumentEncoder&) const { }
-inline bool SandboxExtension::Handle::decode(CoreIPC::ArgumentDecoder*, Handle&) { return true; }
+inline bool SandboxExtension::Handle::decode(CoreIPC::ArgumentDecoder&, Handle&) { return true; }
 inline SandboxExtension::HandleArray::HandleArray() { }
 inline SandboxExtension::HandleArray::~HandleArray() { }
 inline void SandboxExtension::HandleArray::allocate(size_t) { }
@@ -122,7 +122,7 @@ inline size_t SandboxExtension::HandleArray::size() const { return 0; }
 inline const SandboxExtension::Handle& SandboxExtension::HandleArray::operator[](size_t) const { return m_emptyHandle; }
 inline SandboxExtension::Handle& SandboxExtension::HandleArray::operator[](size_t) { return m_emptyHandle; }
 inline void SandboxExtension::HandleArray::encode(CoreIPC::ArgumentEncoder&) const { }
-inline bool SandboxExtension::HandleArray::decode(CoreIPC::ArgumentDecoder*, HandleArray&) { return true; }
+inline bool SandboxExtension::HandleArray::decode(CoreIPC::ArgumentDecoder&, HandleArray&) { return true; }
 inline PassRefPtr<SandboxExtension> SandboxExtension::create(const Handle&) { return 0; }
 inline void SandboxExtension::createHandle(const String&, Type, Handle&) { }
 inline void SandboxExtension::createHandleForReadWriteDirectory(const String&, Handle&) { }
index 4968036..ceccbe0 100644 (file)
@@ -42,13 +42,13 @@ void SecurityOriginData::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << port;
 }
 
-bool SecurityOriginData::decode(CoreIPC::ArgumentDecoder* decoder, SecurityOriginData& securityOriginData)
+bool SecurityOriginData::decode(CoreIPC::ArgumentDecoder& decoder, SecurityOriginData& securityOriginData)
 {
-    if (!decoder->decode(securityOriginData.protocol))
+    if (!decoder.decode(securityOriginData.protocol))
         return false;
-    if (!decoder->decode(securityOriginData.host))
+    if (!decoder.decode(securityOriginData.host))
         return false;
-    if (!decoder->decode(securityOriginData.port))
+    if (!decoder.decode(securityOriginData.port))
         return false;
 
     return true;
index 93909bc..7247ac5 100644 (file)
@@ -41,7 +41,7 @@ typedef GenericCallback<WKArrayRef> ArrayCallback;
 
 struct SecurityOriginData {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, SecurityOriginData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, SecurityOriginData&);
 
     // FIXME <rdar://9018386>: We should be sending more state across the wire than just the protocol,
     // host, and port.
index c08e9aa..2e1bdbb 100644 (file)
@@ -35,9 +35,9 @@ template<typename T> struct ArgumentCoder<RefPtr<T> > {
         item->encode(encoder);
     }
 
-    static bool decode(ArgumentDecoder* decoder, RefPtr<T>& item)
+    static bool decode(ArgumentDecoder& decoder, RefPtr<T>& item)
     {
-        item = T::decode(*decoder);
+        item = T::decode(decoder);
         return item;
     }
 };
@@ -70,11 +70,11 @@ void SessionState::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_currentIndex;
 }
 
-bool SessionState::decode(CoreIPC::ArgumentDecoder* decoder, SessionState& state)
+bool SessionState::decode(CoreIPC::ArgumentDecoder& decoder, SessionState& state)
 {
-    if (!decoder->decode(state.m_list))
+    if (!decoder.decode(state.m_list))
         return false;
-    if (!decoder->decode(state.m_currentIndex))
+    if (!decoder.decode(state.m_currentIndex))
         return false;
     return true;
 }
index 19422a1..c27b7b7 100644 (file)
@@ -46,7 +46,7 @@ public:
     bool isEmpty() const;
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, SessionState&);
+    static bool decode(CoreIPC::ArgumentDecoder&, SessionState&);
 
 private:
     BackForwardListItemVector m_list;
index 8c0deaf..0f06c86 100644 (file)
@@ -46,13 +46,13 @@ void ShareableBitmap::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_flags;
 }
 
-bool ShareableBitmap::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)
+bool ShareableBitmap::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
 {
-    if (!decoder->decode(handle.m_handle))
+    if (!decoder.decode(handle.m_handle))
         return false;
-    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;
     return true;
 }
index a00f1a7..0a01b8e 100644 (file)
@@ -73,7 +73,7 @@ public:
         bool isNull() const { return m_handle.isNull(); }
 
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, Handle&);
+        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
 
     private:
         friend class ShareableBitmap;
index bd98629..f7efe88 100644 (file)
@@ -41,13 +41,13 @@ void ShareableResource::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_size;
 }
 
-bool ShareableResource::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)
+bool ShareableResource::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
 {
-    if (!decoder->decode(handle.m_handle))
+    if (!decoder.decode(handle.m_handle))
         return false;
-    if (!decoder->decode(handle.m_offset))
+    if (!decoder.decode(handle.m_offset))
         return false;
-    if (!decoder->decode(handle.m_size))
+    if (!decoder.decode(handle.m_size))
         return false;
     return true;
 }
index 76f0e4c..b7c35bf 100644 (file)
@@ -46,7 +46,7 @@ public:
         unsigned size() const { return m_size; }
 
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, Handle&);
+        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
 
     private:
         friend class ShareableResource;
index 87f496d..df4244d 100644 (file)
@@ -46,14 +46,14 @@ void SharedWorkerProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& enc
 #endif
 }
 
-bool SharedWorkerProcessCreationParameters::decode(CoreIPC::ArgumentDecoder* decoder, SharedWorkerProcessCreationParameters& result)
+bool SharedWorkerProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, SharedWorkerProcessCreationParameters& result)
 {
-    if (!decoder->decode(result.minimumLifetime))
+    if (!decoder.decode(result.minimumLifetime))
         return false;
-    if (!decoder->decode(result.terminationTimeout))
+    if (!decoder.decode(result.terminationTimeout))
         return false;
 #if PLATFORM(MAC)
-    if (!decoder->decode(result.parentProcessName))
+    if (!decoder.decode(result.parentProcessName))
         return false;
 #endif
 
index ccd257e..8b841f4 100644 (file)
@@ -45,7 +45,7 @@ struct SharedWorkerProcessCreationParameters {
     SharedWorkerProcessCreationParameters();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, SharedWorkerProcessCreationParameters&);
+    static bool decode(CoreIPC::ArgumentDecoder&, SharedWorkerProcessCreationParameters&);
 
     double minimumLifetime;
     double terminationTimeout;
index 17dcdd9..24a85d3 100644 (file)
@@ -38,15 +38,15 @@ void StatisticsData::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << webCoreCacheStatistics;
 }
 
-bool StatisticsData::decode(CoreIPC::ArgumentDecoder* decoder, StatisticsData& statisticsData)
+bool StatisticsData::decode(CoreIPC::ArgumentDecoder& decoder, StatisticsData& statisticsData)
 {
-    if (!decoder->decode(statisticsData.statisticsNumbers))
+    if (!decoder.decode(statisticsData.statisticsNumbers))
         return false;
-    if (!decoder->decode(statisticsData.javaScriptProtectedObjectTypeCounts))
+    if (!decoder.decode(statisticsData.javaScriptProtectedObjectTypeCounts))
         return false;
-    if (!decoder->decode(statisticsData.javaScriptObjectTypeCounts))
+    if (!decoder.decode(statisticsData.javaScriptObjectTypeCounts))
         return false;
-    if (!decoder->decode(statisticsData.webCoreCacheStatistics))
+    if (!decoder.decode(statisticsData.webCoreCacheStatistics))
         return false;
 
     return true;
index 7315ed2..93fb39d 100644 (file)
@@ -37,7 +37,7 @@ namespace WebKit {
 
 struct StatisticsData {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, StatisticsData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, StatisticsData&);
     
     HashMap<String, uint64_t> statisticsNumbers;
     HashMap<String, uint64_t> javaScriptProtectedObjectTypeCounts;
index 8cfd19d..ffebb66 100644 (file)
@@ -50,9 +50,9 @@ public:
         encoder << m_stringPairVector;
     }
 
-    static bool decode(CoreIPC::ArgumentDecoder* decoder, StringPairVector& stringPairVector)
+    static bool decode(CoreIPC::ArgumentDecoder& decoder, StringPairVector& stringPairVector)
     {
-        return decoder->decode(stringPairVector.m_stringPairVector);
+        return decoder.decode(stringPairVector.m_stringPairVector);
     }
 
     const Vector<std::pair<String, String> >& stringPairVector() const { return m_stringPairVector; }
index cf6b906..daf14e2 100644 (file)
@@ -43,25 +43,25 @@ void UpdateInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << bitmapOffset;
 }
 
-bool UpdateInfo::decode(CoreIPC::ArgumentDecoder* decoder, UpdateInfo& result)
+bool UpdateInfo::decode(CoreIPC::ArgumentDecoder& decoder, UpdateInfo& result)
 {
-    if (!decoder->decode(result.viewSize))
+    if (!decoder.decode(result.viewSize))
         return false;
-    if (!decoder->decode(result.deviceScaleFactor))
+    if (!decoder.decode(result.deviceScaleFactor))
         return false;
-    if (!decoder->decode(result.scrollRect))
+    if (!decoder.decode(result.scrollRect))
         return false;
-    if (!decoder->decode(result.scrollOffset))
+    if (!decoder.decode(result.scrollOffset))
         return false;
-    if (!decoder->decode(result.updateRectBounds))
+    if (!decoder.decode(result.updateRectBounds))
         return false;
-    if (!decoder->decode(result.updateRects))
+    if (!decoder.decode(result.updateRects))
         return false;
-    if (!decoder->decode(result.updateScaleFactor))
+    if (!decoder.decode(result.updateScaleFactor))
         return false;
-    if (!decoder->decode(result.bitmapHandle))
+    if (!decoder.decode(result.bitmapHandle))
         return false;
-    if (!decoder->decode(result.bitmapOffset))
+    if (!decoder.decode(result.bitmapOffset))
         return false;
 
     return true;
index c11aa35..b3b9285 100644 (file)
@@ -44,7 +44,7 @@ public:
     UpdateInfo() { }
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, UpdateInfo&);
+    static bool decode(CoreIPC::ArgumentDecoder&, UpdateInfo&);
 
     // The size of the web view.
     WebCore::IntSize viewSize;
index 085c3b2..eb6bec9 100644 (file)
@@ -260,10 +260,10 @@ protected:
 template<typename Owner>
 class UserMessageDecoder {
 public:
-    static bool baseDecode(CoreIPC::ArgumentDecoder* decoder, Owner& coder, APIObject::Type& type)
+    static bool baseDecode(CoreIPC::ArgumentDecoder& decoder, Owner& coder, APIObject::Type& type)
     {
         uint32_t typeAsUInt32;
-        if (!decoder->decode(typeAsUInt32))
+        if (!decoder.decode(typeAsUInt32))
             return false;
 
         type = static_cast<APIObject::Type>(typeAsUInt32);
@@ -271,14 +271,14 @@ public:
         switch (type) {
         case APIObject::TypeArray: {
             uint64_t size;
-            if (!decoder->decode(size))
+            if (!decoder.decode(size))
                 return false;
 
             Vector<RefPtr<APIObject> > vector;
             for (size_t i = 0; i < size; ++i) {
                 RefPtr<APIObject> element;
                 Owner messageCoder(coder, element);
-                if (!decoder->decode(messageCoder))
+                if (!decoder.decode(messageCoder))
                     return false;
                 vector.append(element.release());
             }
@@ -288,18 +288,18 @@ public:
         }
         case APIObject::TypeDictionary: {
             uint64_t size;
-            if (!decoder->decode(size))
+            if (!decoder.decode(size))
                 return false;
 
             ImmutableDictionary::MapType map;
             for (size_t i = 0; i < size; ++i) {
                 String key;
-                if (!decoder->decode(key))
+                if (!decoder.decode(key))
                     return false;
 
                 RefPtr<APIObject> element;
                 Owner messageCoder(coder, element);
-                if (!decoder->decode(messageCoder))
+                if (!decoder.decode(messageCoder))
                     return false;
 
                 ImmutableDictionary::MapType::AddResult result = map.set(key, element.release());
@@ -312,14 +312,14 @@ public:
         }
         case APIObject::TypeString: {
             String string;
-            if (!decoder->decode(string))
+            if (!decoder.decode(string))
                 return false;
             coder.m_root = WebString::create(string);
             break;
         }
         case APIObject::TypeSerializedScriptValue: {
             CoreIPC::DataReference dataReference;
-            if (!decoder->decode(dataReference))
+            if (!decoder.decode(dataReference))
                 return false;
             
             Vector<uint8_t> vector = dataReference.vector();
@@ -328,21 +328,21 @@ public:
         }
         case APIObject::TypeDouble: {
             double value;
-            if (!decoder->decode(value))
+            if (!decoder.decode(value))
                 return false;
             coder.m_root = WebDouble::create(value);
             break;
         }
         case APIObject::TypeUInt64: {
             uint64_t value;
-            if (!decoder->decode(value))
+            if (!decoder.decode(value))
                 return false;
             coder.m_root = WebUInt64::create(value);
             break;
         }
         case APIObject::TypeBoolean: {
             bool value;
-            if (!decoder->decode(value))
+            if (!decoder.decode(value))
                 return false;
             coder.m_root = WebBoolean::create(value);
             break;
@@ -350,9 +350,9 @@ public:
         case APIObject::TypeSize: {
             double width;
             double height;
-            if (!decoder->decode(width))
+            if (!decoder.decode(width))
                 return false;
-            if (!decoder->decode(height))
+            if (!decoder.decode(height))
                 return false;
             coder.m_root = WebSize::create(WKSizeMake(width, height));
             break;
@@ -360,9 +360,9 @@ public:
         case APIObject::TypePoint: {
             double x;
             double y;
-            if (!decoder->decode(x))
+            if (!decoder.decode(x))
                 return false;
-            if (!decoder->decode(y))
+            if (!decoder.decode(y))
                 return false;
             coder.m_root = WebPoint::create(WKPointMake(x, y));
             break;
@@ -372,13 +372,13 @@ public:
             double y;
             double width;
             double height;
-            if (!decoder->decode(x))
+            if (!decoder.decode(x))
                 return false;
-            if (!decoder->decode(y))
+            if (!decoder.decode(y))
                 return false;
-            if (!decoder->decode(width))
+            if (!decoder.decode(width))
                 return false;
-            if (!decoder->decode(height))
+            if (!decoder.decode(height))
                 return false;
             coder.m_root = WebRect::create(WKRectMake(x, y, width, height));
             break;
@@ -395,28 +395,28 @@ public:
             RefPtr<APIObject> positiveZOrderList;
 
             Owner rendererCoder(coder, renderer);
-            if (!decoder->decode(rendererCoder))
+            if (!decoder.decode(rendererCoder))
                 return false;
             if (renderer->type() != APIObject::TypeRenderObject)
                 return false;
-            if (!decoder->decode(isReflection))
+            if (!decoder.decode(isReflection))
                 return false;
-            if (!decoder->decode(isClipping))
+            if (!decoder.decode(isClipping))
                 return false;
-            if (!decoder->decode(isClipped))
+            if (!decoder.decode(isClipped))
                 return false;
-            if (!decoder->decode(compositingLayerTypeAsUInt32))
+            if (!decoder.decode(compositingLayerTypeAsUInt32))
                 return false;
-            if (!decoder->decode(absoluteBoundingBox))
+            if (!decoder.decode(absoluteBoundingBox))
                 return false;
             Owner negativeZOrderListCoder(coder, negativeZOrderList);
-            if (!decoder->decode(negativeZOrderListCoder))
+            if (!decoder.decode(negativeZOrderListCoder))
                 return false;
             Owner normalFlowListCoder(coder, normalFlowList);
-            if (!decoder->decode(normalFlowListCoder))
+            if (!decoder.decode(normalFlowListCoder))
                 return false;
             Owner positiveZOrderListCoder(coder, positiveZOrderList);
-            if (!decoder->decode(positiveZOrderListCoder))
+            if (!decoder.decode(positiveZOrderListCoder))
                 return false;
             coder.m_root = WebRenderLayer::create(static_pointer_cast<WebRenderObject>(renderer), isReflection, isClipping, isClipped, static_cast<WebRenderLayer::CompositingLayerType>(compositingLayerTypeAsUInt32),
                 absoluteBoundingBox, static_pointer_cast<MutableArray>(negativeZOrderList), static_pointer_cast<MutableArray>(normalFlowList),
@@ -432,21 +432,21 @@ public:
             WebCore::IntRect frameRect;
             RefPtr<APIObject> children;
             
-            if (!decoder->decode(name))
+            if (!decoder.decode(name))
                 return false;
-            if (!decoder->decode(elementTagName))
+            if (!decoder.decode(elementTagName))
                 return false;
-            if (!decoder->decode(elementID))
+            if (!decoder.decode(elementID))
                 return false;
             Owner classNamesCoder(coder, elementClassNames);
-            if (!decoder->decode(classNamesCoder))
+            if (!decoder.decode(classNamesCoder))
                 return false;
-            if (!decoder->decode(absolutePosition))
+            if (!decoder.decode(absolutePosition))
                 return false;
-            if (!decoder->decode(frameRect))
+            if (!decoder.decode(frameRect))
                 return false;
             Owner messageCoder(coder, children);
-            if (!decoder->decode(messageCoder))
+            if (!decoder.decode(messageCoder))
                 return false;
             if (children && children->type() != APIObject::TypeArray)
                 return false;
@@ -455,42 +455,42 @@ public:
         }
         case APIObject::TypeURL: {
             String string;
-            if (!decoder->decode(string))
+            if (!decoder.decode(string))
                 return false;
             coder.m_root = WebURL::create(string);
             break;
         }
         case APIObject::TypeURLRequest: {
             WebCore::ResourceRequest request;
-            if (!decoder->decode(request))
+            if (!decoder.decode(request))
                 return false;
             coder.m_root = WebURLRequest::create(request);
             break;
         }
         case APIObject::TypeURLResponse: {
             WebCore::ResourceResponse response;
-            if (!decoder->decode(response))
+            if (!decoder.decode(response))
                 return false;
             coder.m_root = WebURLResponse::create(response);
             break;
         }
         case APIObject::TypeUserContentURLPattern: {
             String string;
-            if (!decoder->decode(string))
+            if (!decoder.decode(string))
                 return false;
             coder.m_root = WebUserContentURLPattern::create(string);
             break;
         }
         case APIObject::TypeImage: {
             bool didEncode = false;
-            if (!decoder->decode(didEncode))
+            if (!decoder.decode(didEncode))
                 return false;
 
             if (!didEncode)
                 break;
 
             ShareableBitmap::Handle handle;
-            if (!decoder->decode(handle))
+            if (!decoder.decode(handle))
                 return false;
 
             coder.m_root = WebImage::create(ShareableBitmap::create(handle));
@@ -498,21 +498,21 @@ public:
         }
         case APIObject::TypeData: {
             CoreIPC::DataReference dataReference;
-            if (!decoder->decode(dataReference))
+            if (!decoder.decode(dataReference))
                 return false;
             coder.m_root = WebData::create(dataReference.data(), dataReference.size());
             break;
         }
         case APIObject::TypeCertificateInfo: {
             PlatformCertificateInfo platformCertificateInfo;
-            if (!decoder->decode(platformCertificateInfo))
+            if (!decoder.decode(platformCertificateInfo))
                 return false;
             coder.m_root = WebCertificateInfo::create(platformCertificateInfo);
             break;
         }
         case APIObject::TypeError: {
             WebCore::ResourceError resourceError;
-            if (!decoder->decode(resourceError))
+            if (!decoder.decode(resourceError))
                 return false;
             coder.m_root = WebError::create(resourceError);
             break;
index 23290b3..bde704e 100644 (file)
@@ -114,30 +114,30 @@ void WebContextMenuItemData::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_submenu;
 }
 
-bool WebContextMenuItemData::decode(CoreIPC::ArgumentDecoder* decoder, WebContextMenuItemData& item)
+bool WebContextMenuItemData::decode(CoreIPC::ArgumentDecoder& decoder, WebContextMenuItemData& item)
 {
     WebCore::ContextMenuItemType type;
-    if (!decoder->decodeEnum(type))
+    if (!decoder.decodeEnum(type))
         return false;
 
     WebCore::ContextMenuAction action;
-    if (!decoder->decodeEnum(action))
+    if (!decoder.decodeEnum(action))
         return false;
 
     String title;
-    if (!decoder->decode(title))
+    if (!decoder.decode(title))
         return false;
 
     bool checked;
-    if (!decoder->decode(checked))
+    if (!decoder.decode(checked))
         return false;
 
     bool enabled;
-    if (!decoder->decode(enabled))
+    if (!decoder.decode(enabled))
         return false;
 
     Vector<WebContextMenuItemData> submenu;
-    if (!decoder->decode(submenu))
+    if (!decoder.decode(submenu))
         return false;
 
     switch (type) {
index 9212e28..9b08190 100644 (file)
@@ -64,7 +64,7 @@ public:
     void setUserData(APIObject*);
     
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebContextMenuItemData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebContextMenuItemData&);
 
 private:
     WebCore::ContextMenuItemType m_type;
index 039b8d6..4f60c45 100644 (file)
@@ -62,7 +62,7 @@ void ArgumentCoder<AffineTransform>::encode(ArgumentEncoder& encoder, const Affi
     SimpleArgumentCoder<AffineTransform>::encode(encoder, affineTransform);
 }
 
-bool ArgumentCoder<AffineTransform>::decode(ArgumentDecoder* decoder, AffineTransform& affineTransform)
+bool ArgumentCoder<AffineTransform>::decode(ArgumentDecoder& decoder, AffineTransform& affineTransform)
 {
     return SimpleArgumentCoder<AffineTransform>::decode(decoder, affineTransform);
 }
@@ -73,7 +73,7 @@ void ArgumentCoder<FloatPoint>::encode(ArgumentEncoder& encoder, const FloatPoin
     SimpleArgumentCoder<FloatPoint>::encode(encoder, floatPoint);
 }
 
-bool ArgumentCoder<FloatPoint>::decode(ArgumentDecoder* decoder, FloatPoint& floatPoint)
+bool ArgumentCoder<FloatPoint>::decode(ArgumentDecoder& decoder, FloatPoint& floatPoint)
 {
     return SimpleArgumentCoder<FloatPoint>::decode(decoder, floatPoint);
 }
@@ -84,7 +84,7 @@ void ArgumentCoder<FloatRect>::encode(ArgumentEncoder& encoder, const FloatRect&
     SimpleArgumentCoder<FloatRect>::encode(encoder, floatRect);
 }
 
-bool ArgumentCoder<FloatRect>::decode(ArgumentDecoder* decoder, FloatRect& floatRect)
+bool ArgumentCoder<FloatRect>::decode(ArgumentDecoder& decoder, FloatRect& floatRect)
 {
     return SimpleArgumentCoder<FloatRect>::decode(decoder, floatRect);
 }
@@ -95,7 +95,7 @@ void ArgumentCoder<FloatSize>::encode(ArgumentEncoder& encoder, const FloatSize&
     SimpleArgumentCoder<FloatSize>::encode(encoder, floatSize);
 }
 
-bool ArgumentCoder<FloatSize>::decode(ArgumentDecoder* decoder, FloatSize& floatSize)
+bool ArgumentCoder<FloatSize>::decode(ArgumentDecoder& decoder, FloatSize& floatSize)
 {
     return SimpleArgumentCoder<FloatSize>::decode(decoder, floatSize);
 }
@@ -106,7 +106,7 @@ void ArgumentCoder<IntPoint>::encode(ArgumentEncoder& encoder, const IntPoint& i
     SimpleArgumentCoder<IntPoint>::encode(encoder, intPoint);
 }
 
-bool ArgumentCoder<IntPoint>::decode(ArgumentDecoder* decoder, IntPoint& intPoint)
+bool ArgumentCoder<IntPoint>::decode(ArgumentDecoder& decoder, IntPoint& intPoint)
 {
     return SimpleArgumentCoder<IntPoint>::decode(decoder, intPoint);
 }
@@ -117,7 +117,7 @@ void ArgumentCoder<IntRect>::encode(ArgumentEncoder& encoder, const IntRect& int
     SimpleArgumentCoder<IntRect>::encode(encoder, intRect);
 }
 
-bool ArgumentCoder<IntRect>::decode(ArgumentDecoder* decoder, IntRect& intRect)
+bool ArgumentCoder<IntRect>::decode(ArgumentDecoder& decoder, IntRect& intRect)
 {
     return SimpleArgumentCoder<IntRect>::decode(decoder, intRect);
 }
@@ -128,7 +128,7 @@ void ArgumentCoder<IntSize>::encode(ArgumentEncoder& encoder, const IntSize& int
     SimpleArgumentCoder<IntSize>::encode(encoder, intSize);
 }
 
-bool ArgumentCoder<IntSize>::decode(ArgumentDecoder* decoder, IntSize& intSize)
+bool ArgumentCoder<IntSize>::decode(ArgumentDecoder& decoder, IntSize& intSize)
 {
     return SimpleArgumentCoder<IntSize>::decode(decoder, intSize);
 }
@@ -139,7 +139,7 @@ void ArgumentCoder<ViewportAttributes>::encode(ArgumentEncoder& encoder, const V
     SimpleArgumentCoder<ViewportAttributes>::encode(encoder, viewportAttributes);
 }
 
-bool ArgumentCoder<ViewportAttributes>::decode(ArgumentDecoder* decoder, ViewportAttributes& viewportAttributes)
+bool ArgumentCoder<ViewportAttributes>::decode(ArgumentDecoder& decoder, ViewportAttributes& viewportAttributes)
 {
     return SimpleArgumentCoder<ViewportAttributes>::decode(decoder, viewportAttributes);
 }
@@ -150,13 +150,13 @@ void ArgumentCoder<MimeClassInfo>::encode(ArgumentEncoder& encoder, const MimeCl
     encoder << mimeClassInfo.type << mimeClassInfo.desc << mimeClassInfo.extensions;
 }
 
-bool ArgumentCoder<MimeClassInfo>::decode(ArgumentDecoder* decoder, MimeClassInfo& mimeClassInfo)
+bool ArgumentCoder<MimeClassInfo>::decode(ArgumentDecoder& decoder, MimeClassInfo& mimeClassInfo)
 {
-    if (!decoder->decode(mimeClassInfo.type))
+    if (!decoder.decode(mimeClassInfo.type))
         return false;
-    if (!decoder->decode(mimeClassInfo.desc))
+    if (!decoder.decode(mimeClassInfo.desc))
         return false;
-    if (!decoder->decode(mimeClassInfo.extensions))
+    if (!decoder.decode(mimeClassInfo.extensions))
         return false;
 
     return true;
@@ -168,15 +168,15 @@ void ArgumentCoder<PluginInfo>::encode(ArgumentEncoder& encoder, const PluginInf
     encoder << pluginInfo.name << pluginInfo.file << pluginInfo.desc << pluginInfo.mimes;
 }
     
-bool ArgumentCoder<PluginInfo>::decode(ArgumentDecoder* decoder, PluginInfo& pluginInfo)
+bool ArgumentCoder<PluginInfo>::decode(ArgumentDecoder& decoder, PluginInfo& pluginInfo)
 {
-    if (!decoder->decode(pluginInfo.name))
+    if (!decoder.decode(pluginInfo.name))
         return false;
-    if (!decoder->decode(pluginInfo.file))
+    if (!decoder.decode(pluginInfo.file))
         return false;
-    if (!decoder->decode(pluginInfo.desc))
+    if (!decoder.decode(pluginInfo.desc))
         return false;
-    if (!decoder->decode(pluginInfo.mimes))
+    if (!decoder.decode(pluginInfo.mimes))
         return false;
 
     return true;
@@ -188,9 +188,9 @@ void ArgumentCoder<HTTPHeaderMap>::encode(ArgumentEncoder& encoder, const HTTPHe
     encoder << static_cast<const HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap);
 }
 
-bool ArgumentCoder<HTTPHeaderMap>::decode(ArgumentDecoder* decoder, HTTPHeaderMap& headerMap)
+bool ArgumentCoder<HTTPHeaderMap>::decode(ArgumentDecoder& decoder, HTTPHeaderMap& headerMap)
 {
-    return decoder->decode(static_cast<HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap));
+    return decoder.decode(static_cast<HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap));
 }
 
 
@@ -199,26 +199,26 @@ void ArgumentCoder<AuthenticationChallenge>::encode(ArgumentEncoder& encoder, co
     encoder << challenge.protectionSpace() << challenge.proposedCredential() << challenge.previousFailureCount() << challenge.failureResponse() << challenge.error();
 }
 
-bool ArgumentCoder<AuthenticationChallenge>::decode(ArgumentDecoder* decoder, AuthenticationChallenge& challenge)
+bool ArgumentCoder<AuthenticationChallenge>::decode(ArgumentDecoder& decoder, AuthenticationChallenge& challenge)
 {    
     ProtectionSpace protectionSpace;
-    if (!decoder->decode(protectionSpace))
+    if (!decoder.decode(protectionSpace))
         return false;
 
     Credential proposedCredential;
-    if (!decoder->decode(proposedCredential))
+    if (!decoder.decode(proposedCredential))
         return false;
 
     unsigned previousFailureCount;    
-    if (!decoder->decode(previousFailureCount))
+    if (!decoder.decode(previousFailureCount))
         return false;
 
     ResourceResponse failureResponse;
-    if (!decoder->decode(failureResponse))
+    if (!decoder.decode(failureResponse))
         return false;
 
     ResourceError error;
-    if (!decoder->decode(error))
+    if (!decoder.decode(error))
         return false;
     
     challenge = AuthenticationChallenge(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error);
@@ -233,26 +233,26 @@ void ArgumentCoder<ProtectionSpace>::encode(ArgumentEncoder& encoder, const Prot
     encoder.encodeEnum(space.serverType());
 }
 
-bool ArgumentCoder<ProtectionSpace>::decode(ArgumentDecoder* decoder, ProtectionSpace& space)
+bool ArgumentCoder<ProtectionSpace>::decode(ArgumentDecoder& decoder, ProtectionSpace& space)
 {
     String host;
-    if (!decoder->decode(host))
+    if (!decoder.decode(host))
         return false;
 
     int port;
-    if (!decoder->decode(port))
+    if (!decoder.decode(port))
         return false;
 
     String realm;
-    if (!decoder->decode(realm))
+    if (!decoder.decode(realm))
         return false;
     
     ProtectionSpaceAuthenticationScheme authenticationScheme;
-    if (!decoder->decodeEnum(authenticationScheme))
+    if (!decoder.decodeEnum(authenticationScheme))
         return false;
 
     ProtectionSpaceServerType serverType;
-    if (!decoder->decodeEnum(serverType))
+    if (!decoder.decodeEnum(serverType))
         return false;
 
     space = ProtectionSpace(host, port, serverType, realm, authenticationScheme);
@@ -265,18 +265,18 @@ void ArgumentCoder<Credential>::encode(ArgumentEncoder& encoder, const Credentia
     encoder.encodeEnum(credential.persistence());
 }
 
-bool ArgumentCoder<Credential>::decode(ArgumentDecoder* decoder, Credential& credential)
+bool ArgumentCoder<Credential>::decode(ArgumentDecoder& decoder, Credential& credential)
 {
     String user;
-    if (!decoder->decode(user))
+    if (!decoder.decode(user))
         return false;
 
     String password;
-    if (!decoder->decode(password))
+    if (!decoder.decode(password))
         return false;
 
     CredentialPersistence persistence;
-    if (!decoder->decodeEnum(persistence))
+    if (!decoder.decodeEnum(persistence))
         return false;
     
     credential = Credential(user, password, persistence);
@@ -294,10 +294,10 @@ static void encodeImage(ArgumentEncoder& encoder, Image* image)
     encoder << handle;
 }
 
-static bool decodeImage(ArgumentDecoder* decoder, RefPtr<Image>& image)
+static bool decodeImage(ArgumentDecoder& decoder, RefPtr<Image>& image)
 {
     ShareableBitmap::Handle handle;
-    if (!decoder->decode(handle))
+    if (!decoder.decode(handle))
         return false;
     
     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(handle);
@@ -326,10 +326,10 @@ void ArgumentCoder<Cursor>::encode(ArgumentEncoder& encoder, const Cursor& curso
     encoder << cursor.hotSpot();
 }
 
-bool ArgumentCoder<Cursor>::decode(ArgumentDecoder* decoder, Cursor& cursor)
+bool ArgumentCoder<Cursor>::decode(ArgumentDecoder& decoder, Cursor& cursor)
 {
     Cursor::Type type;
-    if (!decoder->decodeEnum(type))
+    if (!decoder.decodeEnum(type))
         return false;
 
     if (type > Cursor::Custom)
@@ -346,7 +346,7 @@ bool ArgumentCoder<Cursor>::decode(ArgumentDecoder* decoder, Cursor& cursor)
     }
 
     bool isValidImagePresent;
-    if (!decoder->decode(isValidImagePresent))
+    if (!decoder.decode(isValidImagePresent))
         return false;
 
     if (!isValidImagePresent) {
@@ -359,7 +359,7 @@ bool ArgumentCoder<Cursor>::decode(ArgumentDecoder* decoder, Cursor& cursor)
         return false;
 
     IntPoint hotSpot;
-    if (!decoder->decode(hotSpot))
+    if (!decoder.decode(hotSpot))
         return false;
 
     if (!image->rect().contains(hotSpot))
@@ -390,38 +390,38 @@ void ArgumentCoder<ResourceRequest>::encode(ArgumentEncoder& encoder, const Reso
     encodePlatformData(encoder, resourceRequest);
 }
 
-bool ArgumentCoder<ResourceRequest>::decode(ArgumentDecoder* decoder, ResourceRequest& resourceRequest)
+bool ArgumentCoder<ResourceRequest>::decode(ArgumentDecoder& decoder, ResourceRequest& resourceRequest)
 {
     if (kShouldSerializeWebCoreData) {
         ResourceRequest request;
 
         String url;
-        if (!decoder->decode(url))
+        if (!decoder.decode(url))
             return false;
         request.setURL(KURL(KURL(), url));
 
         String httpMethod;
-        if (!decoder->decode(httpMethod))
+        if (!decoder.decode(httpMethod))
             return false;
         request.setHTTPMethod(httpMethod);
 
         HTTPHeaderMap headers;
-        if (!decoder->decode(headers))
+        if (!decoder.decode(headers))
             return false;
         request.addHTTPHeaderFields(headers);
 
         bool hasHTTPBody;
-        if (!decoder->decode(hasHTTPBody))
+        if (!decoder.decode(hasHTTPBody))
             return false;
         if (hasHTTPBody) {
             String httpBody;
-            if (!decoder->decode(httpBody))
+            if (!decoder.decode(httpBody))
                 return false;
             request.setHTTPBody(FormData::create(httpBody.utf8()));
         }
 
         String firstPartyForCookies;
-        if (!decoder->decode(firstPartyForCookies))
+        if (!decoder.decode(firstPartyForCookies))
             return false;
         request.setFirstPartyForCookies(KURL(KURL(), firstPartyForCookies));
 
@@ -453,11 +453,11 @@ void ArgumentCoder<ResourceResponse>::encode(ArgumentEncoder& encoder, const Res
     encodePlatformData(encoder, resourceResponse);
 }
 
-bool ArgumentCoder<ResourceResponse>::decode(ArgumentDecoder* decoder, ResourceResponse& resourceResponse)
+bool ArgumentCoder<ResourceResponse>::decode(ArgumentDecoder& decoder, ResourceResponse& resourceResponse)
 {
     if (kShouldSerializeWebCoreData) {
         bool responseIsNull;
-        if (!decoder->decode(responseIsNull))
+        if (!decoder.decode(responseIsNull))
             return false;
         if (responseIsNull) {
             resourceResponse = ResourceResponse();
@@ -467,43 +467,43 @@ bool ArgumentCoder<ResourceResponse>::decode(ArgumentDecoder* decoder, ResourceR
         ResourceResponse response;
 
         String url;
-        if (!decoder->decode(url))
+        if (!decoder.decode(url))
             return false;
         response.setURL(KURL(KURL(), url));
 
         int32_t httpStatusCode;
-        if (!decoder->decode(httpStatusCode))
+        if (!decoder.decode(httpStatusCode))
             return false;
         response.setHTTPStatusCode(httpStatusCode);
 
         HTTPHeaderMap headers;
-        if (!decoder->decode(headers))
+        if (!decoder.decode(headers))
             return false;
         for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it)
             response.setHTTPHeaderField(it->key, it->value);
 
         String mimeType;
-        if (!decoder->decode(mimeType))
+        if (!decoder.decode(mimeType))
             return false;
         response.setMimeType(mimeType);
 
         String textEncodingName;
-        if (!decoder->decode(textEncodingName))
+        if (!decoder.decode(textEncodingName))
             return false;
         response.setTextEncodingName(textEncodingName);
 
         int64_t contentLength;
-        if (!decoder->decode(contentLength))
+        if (!decoder.decode(contentLength))
             return false;
         response.setExpectedContentLength(contentLength);
 
         String httpStatusText;
-        if (!decoder->decode(httpStatusText))
+        if (!decoder.decode(httpStatusText))
             return false;
         response.setHTTPStatusText(httpStatusText);
 
         String suggestedFilename;
-        if (!decoder->decode(suggestedFilename))
+        if (!decoder.decode(suggestedFilename))
             return false;
         response.setSuggestedFilename(suggestedFilename);
 
@@ -532,11 +532,11 @@ void ArgumentCoder<ResourceError>::encode(ArgumentEncoder& encoder, const Resour
     encodePlatformData(encoder, resourceError);
 }
 
-bool ArgumentCoder<ResourceError>::decode(ArgumentDecoder* decoder, ResourceError& resourceError)
+bool ArgumentCoder<ResourceError>::decode(ArgumentDecoder& decoder, ResourceError& resourceError)
 {
     if (kShouldSerializeWebCoreData) {
         bool errorIsNull;
-        if (!decoder->decode(errorIsNull))
+        if (!decoder.decode(errorIsNull))
             return false;
         if (errorIsNull) {
             resourceError = ResourceError();
@@ -544,27 +544,27 @@ bool ArgumentCoder<ResourceError>::decode(ArgumentDecoder* decoder, ResourceErro
         }
 
         String domain;
-        if (!decoder->decode(domain))
+        if (!decoder.decode(domain))
             return false;
 
         int errorCode;
-        if (!decoder->decode(errorCode))
+        if (!decoder.decode(errorCode))
             return false;
 
         String failingURL;
-        if (!decoder->decode(failingURL))
+        if (!decoder.decode(failingURL))
             return false;
 
         String localizedDescription;
-        if (!decoder->decode(localizedDescription))
+        if (!decoder.decode(localizedDescription))
             return false;
 
         bool isCancellation;
-        if (!decoder->decode(isCancellation))
+        if (!decoder.decode(isCancellation))
             return false;
 
         bool isTimeout;
-        if (!decoder->decode(isTimeout))
+        if (!decoder.decode(isTimeout))
             return false;
 
         resourceError = ResourceError(domain, errorCode, failingURL, localizedDescription);
@@ -595,39 +595,39 @@ void ArgumentCoder<WindowFeatures>::encode(ArgumentEncoder& encoder, const Windo
     encoder << windowFeatures.dialog;
 }
 
-bool ArgumentCoder<WindowFeatures>::decode(ArgumentDecoder* decoder, WindowFeatures& windowFeatures)
+bool ArgumentCoder<WindowFeatures>::decode(ArgumentDecoder& decoder, WindowFeatures& windowFeatures)
 {
-    if (!decoder->decode(windowFeatures.x))
+    if (!decoder.decode(windowFeatures.x))
         return false;
-    if (!decoder->decode(windowFeatures.y))
+    if (!decoder.decode(windowFeatures.y))
         return false;
-    if (!decoder->decode(windowFeatures.width))
+    if (!decoder.decode(windowFeatures.width))
         return false;
-    if (!decoder->decode(windowFeatures.height))
+    if (!decoder.decode(windowFeatures.height))
         return false;
-    if (!decoder->decode(windowFeatures.xSet))
+    if (!decoder.decode(windowFeatures.xSet))
         return false;
-    if (!decoder->decode(windowFeatures.ySet))
+    if (!decoder.decode(windowFeatures.ySet))
         return false;
-    if (!decoder->decode(windowFeatures.widthSet))
+    if (!decoder.decode(windowFeatures.widthSet))
         return false;
-    if (!decoder->decode(windowFeatures.heightSet))
+    if (!decoder.decode(windowFeatures.heightSet))
         return false;
-    if (!decoder->decode(windowFeatures.menuBarVisible))
+    if (!decoder.decode(windowFeatures.menuBarVisible))
         return false;
-    if (!decoder->decode(windowFeatures.statusBarVisible))
+    if (!decoder.decode(windowFeatures.statusBarVisible))
         return false;
-    if (!decoder->decode(windowFeatures.toolBarVisible))
+    if (!decoder.decode(windowFeatures.toolBarVisible))
         return false;
-    if (!decoder->decode(windowFeatures.locationBarVisible))
+    if (!decoder.decode(windowFeatures.locationBarVisible))
         return false;
-    if (!decoder->decode(windowFeatures.scrollbarsVisible))
+    if (!decoder.decode(windowFeatures.scrollbarsVisible))
         return false;
-    if (!decoder->decode(windowFeatures.resizable))
+    if (!decoder.decode(windowFeatures.resizable))
         return false;
-    if (!decoder->decode(windowFeatures.fullscreen))
+    if (!decoder.decode(windowFeatures.fullscreen))
         return false;
-    if (!decoder->decode(windowFeatures.dialog))
+    if (!decoder.decode(windowFeatures.dialog))
         return false;
     return true;
 }
@@ -644,10 +644,10 @@ void ArgumentCoder<Color>::encode(ArgumentEncoder& encoder, const Color& color)
     encoder << color.rgb();
 }
 
-bool ArgumentCoder<Color>::decode(ArgumentDecoder* decoder, Color& color)
+bool ArgumentCoder<Color>::decode(ArgumentDecoder& decoder, Color& color)
 {
     bool isValid;
-    if (!decoder->decode(isValid))
+    if (!decoder.decode(isValid))
         return false;
 
     if (!isValid) {
@@ -656,7 +656,7 @@ bool ArgumentCoder<Color>::decode(ArgumentDecoder* decoder, Color& color)
     }
 
     RGBA32 rgba;
-    if (!decoder->decode(rgba))
+    if (!decoder.decode(rgba))
         return false;
 
     color = Color(rgba);
@@ -672,15 +672,15 @@ void ArgumentCoder<CompositionUnderline>::encode(ArgumentEncoder& encoder, const
     encoder << underline.color;
 }
 
-bool ArgumentCoder<CompositionUnderline>::decode(ArgumentDecoder* decoder, CompositionUnderline& underline)
+bool ArgumentCoder<CompositionUnderline>::decode(ArgumentDecoder& decoder, CompositionUnderline& underline)
 {
-    if (!decoder->decode(underline.startOffset))
+    if (!decoder.decode(underline.startOffset))
         return false;
-    if (!decoder->decode(underline.endOffset))
+    if (!decoder.decode(underline.endOffset))
         return false;
-    if (!decoder->decode(underline.thick))
+    if (!decoder.decode(underline.thick))
         return false;
-    if (!decoder->decode(underline.color))
+    if (!decoder.decode(underline.color))
         return false;
 
     return true;
@@ -699,23 +699,23 @@ void ArgumentCoder<Cookie>::encode(ArgumentEncoder& encoder, const Cookie& cooki
     encoder << cookie.session;
 }
 
-bool ArgumentCoder<Cookie>::decode(ArgumentDecoder* decoder, Cookie& cookie)
+bool ArgumentCoder<Cookie>::decode(ArgumentDecoder& decoder, Cookie& cookie)
 {
-    if (!decoder->decode(cookie.name))
+    if (!decoder.decode(cookie.name))
         return false;
-    if (!decoder->decode(cookie.value))
+    if (!decoder.decode(cookie.value))
         return false;
-    if (!decoder->decode(cookie.domain))
+    if (!decoder.decode(cookie.domain))
         return false;
-    if (!decoder->decode(cookie.path))
+    if (!decoder.decode(cookie.path))
         return false;
-    if (!decoder->decode(cookie.expires))
+    if (!decoder.decode(cookie.expires))
         return false;
-    if (!decoder->decode(cookie.httpOnly))
+    if (!decoder.decode(cookie.httpOnly))
         return false;
-    if (!decoder->decode(cookie.secure))
+    if (!decoder.decode(cookie.secure))
         return false;
-    if (!decoder->decode(cookie.session))
+    if (!decoder.decode(cookie.session))
         return false;
 
     return true;
@@ -731,22 +731,22 @@ void ArgumentCoder<DatabaseDetails>::encode(ArgumentEncoder& encoder, const Data
     encoder << details.currentUsage();
 }
     
-bool ArgumentCoder<DatabaseDetails>::decode(ArgumentDecoder* decoder, DatabaseDetails& details)
+bool ArgumentCoder<DatabaseDetails>::decode(ArgumentDecoder& decoder, DatabaseDetails& details)
 {
     String name;
-    if (!decoder->decode(name))
+    if (!decoder.decode(name))
         return false;
 
     String displayName;
-    if (!decoder->decode(displayName))
+    if (!decoder.decode(displayName))
         return false;
 
     uint64_t expectedUsage;
-    if (!decoder->decode(expectedUsage))
+    if (!decoder.decode(expectedUsage))
         return false;
 
     uint64_t currentUsage;
-    if (!decoder->decode(currentUsage))
+    if (!decoder.decode(currentUsage))
         return false;
     
     details = DatabaseDetails(name, displayName, expectedUsage, currentUsage);
@@ -761,13 +761,13 @@ void ArgumentCoder<DictationAlternative>::encode(ArgumentEncoder& encoder, const
     encoder << dictationAlternative.dictationContext;
 }
 
-bool ArgumentCoder<DictationAlternative>::decode(ArgumentDecoder* decoder, DictationAlternative& dictationAlternative)
+bool ArgumentCoder<DictationAlternative>::decode(ArgumentDecoder& decoder, DictationAlternative& dictationAlternative)
 {
-    if (!decoder->decode(dictationAlternative.rangeStart))
+    if (!decoder.decode(dictationAlternative.rangeStart))
         return false;
-    if (!decoder->decode(dictationAlternative.rangeLength))
+    if (!decoder.decode(dictationAlternative.rangeLength))
         return false;
-    if (!decoder->decode(dictationAlternative.dictationContext))
+    if (!decoder.decode(dictationAlternative.dictationContext))
         return false;
     return true;
 }
@@ -786,20 +786,20 @@ void ArgumentCoder<FileChooserSettings>::encode(ArgumentEncoder& encoder, const
 #endif
 }
 
-bool ArgumentCoder<FileChooserSettings>::decode(ArgumentDecoder* decoder, FileChooserSettings& settings)
+bool ArgumentCoder<FileChooserSettings>::decode(ArgumentDecoder& decoder, FileChooserSettings& settings)
 {
-    if (!decoder->decode(settings.allowsMultipleFiles))
+    if (!decoder.decode(settings.allowsMultipleFiles))
         return false;
 #if ENABLE(DIRECTORY_UPLOAD)
-    if (!decoder->decode(settings.allowsDirectoryUpload))
+    if (!decoder.decode(settings.allowsDirectoryUpload))
         return false;
 #endif
-    if (!decoder->decode(settings.acceptMIMETypes))
+    if (!decoder.decode(settings.acceptMIMETypes))
         return false;
-    if (!decoder->decode(settings.selectedFiles))
+    if (!decoder.decode(settings.selectedFiles))
         return false;
 #if ENABLE(MEDIA_CAPTURE)
-    if (!decoder->decode(settings.capture))
+    if (!decoder.decode(settings.capture))
         return false;
 #endif
 
@@ -815,15 +815,15 @@ void ArgumentCoder<GrammarDetail>::encode(ArgumentEncoder& encoder, const Gramma
     encoder << detail.userDescription;
 }
 
-bool ArgumentCoder<GrammarDetail>::decode(ArgumentDecoder* decoder, GrammarDetail& detail)
+bool ArgumentCoder<GrammarDetail>::decode(ArgumentDecoder& decoder, GrammarDetail& detail)
 {
-    if (!decoder->decode(detail.location))
+    if (!decoder.decode(detail.location))
         return false;
-    if (!decoder->decode(detail.length))
+    if (!decoder.decode(detail.length))
         return false;
-    if (!decoder->decode(detail.guesses))
+    if (!decoder.decode(detail.guesses))
         return false;
-    if (!decoder->decode(detail.userDescription))
+    if (!decoder.decode(detail.userDescription))
         return false;
 
     return true;
@@ -839,17 +839,17 @@ void ArgumentCoder<TextCheckingResult>::encode(ArgumentEncoder& encoder, const T
     encoder << result.replacement;
 }
 
-bool ArgumentCoder<TextCheckingResult>::decode(ArgumentDecoder* decoder, TextCheckingResult& result)
+bool ArgumentCoder<TextCheckingResult>::decode(ArgumentDecoder& decoder, TextCheckingResult& result)
 {
-    if (!decoder->decodeEnum(result.type))
+    if (!decoder.decodeEnum(result.type))
         return false;
-    if (!decoder->decode(result.location))
+    if (!decoder.decode(result.location))
         return false;
-    if (!decoder->decode(result.length))
+    if (!decoder.decode(result.length))
         return false;
-    if (!decoder->decode(result.details))
+    if (!decoder.decode(result.details))
         return false;
-    if (!decoder->decode(result.replacement))
+    if (!decoder.decode(result.replacement))
         return false;
     return true;
 }
@@ -861,13 +861,13 @@ void ArgumentCoder<DragSession>::encode(ArgumentEncoder& encoder, const DragSess
     encoder << result.numberOfItemsToBeAccepted;
 }
 
-bool ArgumentCoder<DragSession>::decode(ArgumentDecoder* decoder, DragSession& result)
+bool ArgumentCoder<DragSession>::decode(ArgumentDecoder& decoder, DragSession& result)
 {
-    if (!decoder->decodeEnum(result.operation))
+    if (!decoder.decodeEnum(result.operation))
         return false;
-    if (!decoder->decode(result.mouseIsOverFileInput))
+    if (!decoder.decode(result.mouseIsOverFileInput))
         return false;
-    if (!decoder->decode(result.numberOfItemsToBeAccepted))
+    if (!decoder.decode(result.numberOfItemsToBeAccepted))
         return false;
     return true;
 }
@@ -877,10 +877,10 @@ void ArgumentCoder<KURL>::encode(ArgumentEncoder& encoder, const KURL& result)
     encoder << result.string();
 }
     
-bool ArgumentCoder<KURL>::decode(ArgumentDecoder* decoder, KURL& result)
+bool ArgumentCoder<KURL>::decode(ArgumentDecoder& decoder, KURL& result)
 {
     String urlAsString;
-    if (!decoder->decode(urlAsString))
+    if (!decoder.decode(urlAsString))
         return false;
     result = KURL(WebCore::ParsedURLString, urlAsString);
     return true;
@@ -896,30 +896,30 @@ void ArgumentCoder<WebCore::UserStyleSheet>::encode(ArgumentEncoder& encoder, co
     encoder.encodeEnum(userStyleSheet.level());
 }
 
-bool ArgumentCoder<WebCore::UserStyleSheet>::decode(ArgumentDecoder* decoder, WebCore::UserStyleSheet& userStyleSheet)
+bool ArgumentCoder<WebCore::UserStyleSheet>::decode(ArgumentDecoder& decoder, WebCore::UserStyleSheet& userStyleSheet)
 {
     String source;
-    if (!decoder->decode(source))
+    if (!decoder.decode(source))
         return false;
 
     KURL url;
-    if (!decoder->decode(url))
+    if (!decoder.decode(url))
         return false;
 
     Vector<String> whitelist;
-    if (!decoder->decode(whitelist))
+    if (!decoder.decode(whitelist))
         return false;
 
     Vector<String> blacklist;
-    if (!decoder->decode(blacklist))
+    if (!decoder.decode(blacklist))
         return false;
 
     WebCore::UserContentInjectedFrames injectedFrames;
-    if (!decoder->decodeEnum(injectedFrames))
+    if (!decoder.decodeEnum(injectedFrames))
         return false;
 
     WebCore::UserStyleLevel level;
-    if (!decoder->decodeEnum(level))
+    if (!decoder.decodeEnum(level))
         return false;
 
     userStyleSheet = WebCore::UserStyleSheet(source, url, whitelist, blacklist, injectedFrames, level);
@@ -936,30 +936,30 @@ void ArgumentCoder<WebCore::UserScript>::encode(ArgumentEncoder& encoder, const
     encoder.encodeEnum(userScript.injectedFrames());
 }
 
-bool ArgumentCoder<WebCore::UserScript>::decode(ArgumentDecoder* decoder, WebCore::UserScript& userScript)
+bool ArgumentCoder<WebCore::UserScript>::decode(ArgumentDecoder& decoder, WebCore::UserScript& userScript)
 {
     String source;
-    if (!decoder->decode(source))
+    if (!decoder.decode(source))
         return false;
 
     KURL url;
-    if (!decoder->decode(url))
+    if (!decoder.decode(url))
         return false;
 
     Vector<String> whitelist;
-    if (!decoder->decode(whitelist))
+    if (!decoder.decode(whitelist))
         return false;
 
     Vector<String> blacklist;
-    if (!decoder->decode(blacklist))
+    if (!decoder.decode(blacklist))
         return false;
 
     WebCore::UserScriptInjectionTime injectionTime;
-    if (!decoder->decodeEnum(injectionTime))
+    if (!decoder.decodeEnum(injectionTime))
         return false;
 
     WebCore::UserContentInjectedFrames injectedFrames;
-    if (!decoder->decodeEnum(injectedFrames))
+    if (!decoder.decodeEnum(injectedFrames))
         return false;
 
     userScript = WebCore::UserScript(source, url, whitelist, blacklist, injectionTime, injectedFrames);
index 93e973e..0d8eb76 100644 (file)
@@ -74,77 +74,77 @@ namespace CoreIPC {
 
 template<> struct ArgumentCoder<WebCore::AffineTransform> {
     static void encode(ArgumentEncoder&, const WebCore::AffineTransform&);
-    static bool decode(ArgumentDecoder*, WebCore::AffineTransform&);
+    static bool decode(ArgumentDecoder&, WebCore::AffineTransform&);
 };
 
 template<> struct ArgumentCoder<WebCore::FloatPoint> {
     static void encode(ArgumentEncoder&, const WebCore::FloatPoint&);
-    static bool decode(ArgumentDecoder*, WebCore::FloatPoint&);
+    static bool decode(ArgumentDecoder&, WebCore::FloatPoint&);
 };
 
 template<> struct ArgumentCoder<WebCore::FloatRect> {
     static void encode(ArgumentEncoder&, const WebCore::FloatRect&);
-    static bool decode(ArgumentDecoder*, WebCore::FloatRect&);
+    static bool decode(ArgumentDecoder&, WebCore::FloatRect&);
 };
 
 template<> struct ArgumentCoder<WebCore::FloatSize> {
     static void encode(ArgumentEncoder&, const WebCore::FloatSize&);
-    static bool decode(ArgumentDecoder*, WebCore::FloatSize&);
+    static bool decode(ArgumentDecoder&, WebCore::FloatSize&);
 };
 
 template<> struct ArgumentCoder<WebCore::IntPoint> {
     static void encode(ArgumentEncoder&, const WebCore::IntPoint&);
-    static bool decode(ArgumentDecoder*, WebCore::IntPoint&);
+    static bool decode(ArgumentDecoder&, WebCore::IntPoint&);
 };
 
 template<> struct ArgumentCoder<WebCore::IntRect> {
     static void encode(ArgumentEncoder&, const WebCore::IntRect&);
-    static bool decode(ArgumentDecoder*, WebCore::IntRect&);
+    static bool decode(ArgumentDecoder&, WebCore::IntRect&);
 };
 
 template<> struct ArgumentCoder<WebCore::IntSize> {
     static void encode(ArgumentEncoder&, const WebCore::IntSize&);
-    static bool decode(ArgumentDecoder*, WebCore::IntSize&);
+    static bool decode(ArgumentDecoder&, WebCore::IntSize&);
 };
 
 template<> struct ArgumentCoder<WebCore::ViewportAttributes> {
     static void encode(ArgumentEncoder&, const WebCore::ViewportAttributes&);
-    static bool decode(ArgumentDecoder*, WebCore::ViewportAttributes&);
+    static bool decode(ArgumentDecoder&, WebCore::ViewportAttributes&);
 };
 
 template<> struct ArgumentCoder<WebCore::MimeClassInfo> {
     static void encode(ArgumentEncoder&, const WebCore::MimeClassInfo&);
-    static bool decode(ArgumentDecoder*, WebCore::MimeClassInfo&);
+    static bool decode(ArgumentDecoder&, WebCore::MimeClassInfo&);
 };
 
 template<> struct ArgumentCoder<WebCore::PluginInfo> {
     static void encode(ArgumentEncoder&, const WebCore::PluginInfo&);
-    static bool decode(ArgumentDecoder*, WebCore::PluginInfo&);
+    static bool decode(ArgumentDecoder&, WebCore::PluginInfo&);
 };
 
 template<> struct ArgumentCoder<WebCore::HTTPHeaderMap> {
     static void encode(ArgumentEncoder&, const WebCore::HTTPHeaderMap&);
-    static bool decode(ArgumentDecoder*, WebCore::HTTPHeaderMap&);
+    static bool decode(ArgumentDecoder&, WebCore::HTTPHeaderMap&);
 };
 
 template<> struct ArgumentCoder<WebCore::AuthenticationChallenge> {
     static void encode(ArgumentEncoder&, const WebCore::AuthenticationChallenge&);
-    static bool decode(ArgumentDecoder*, WebCore::AuthenticationChallenge&);
+    static bool decode(ArgumentDecoder&, WebCore::AuthenticationChallenge&);
 };
 
 template<> struct ArgumentCoder<WebCore::ProtectionSpace> {
     static void encode(ArgumentEncoder&, const WebCore::ProtectionSpace&);
-    static bool decode(ArgumentDecoder*, WebCore::ProtectionSpace&);
+    static bool decode(ArgumentDecoder&, WebCore::ProtectionSpace&);
 };
 
 template<> struct ArgumentCoder<WebCore::Credential> {
     static void encode(ArgumentEncoder&, const WebCore::Credential&);
-    static bool decode(ArgumentDecoder*, WebCore::Credential&);
+    static bool decode(ArgumentDecoder&, WebCore::Credential&);
 };
 
 template<> struct ArgumentCoder<WebCore::Cursor> {
     static void encode(ArgumentEncoder&, const WebCore::Cursor&);
-    static bool decode(ArgumentDecoder*, WebCore::Cursor&);
+    static bool decode(ArgumentDecoder&, WebCore::Cursor&);
 };
 
 template<> struct ArgumentCoder<WebCore::ResourceRequest> {
@@ -155,9 +155,9 @@ template<> struct ArgumentCoder<WebCore::ResourceRequest> {
 #endif
 
     static void encode(ArgumentEncoder&, const WebCore::ResourceRequest&);
-    static bool decode(ArgumentDecoder*, WebCore::ResourceRequest&);
+    static bool decode(ArgumentDecoder&, WebCore::ResourceRequest&);
     static void encodePlatformData(ArgumentEncoder&, const WebCore::ResourceRequest&);
-    static bool decodePlatformData(ArgumentDecoder*, WebCore::ResourceRequest&);
+    static bool decodePlatformData(ArgumentDecoder&, WebCore::ResourceRequest&);
 };
 
 template<> struct ArgumentCoder<WebCore::ResourceResponse> {
@@ -168,9 +168,9 @@ template<> struct ArgumentCoder<WebCore::ResourceResponse> {
 #endif
 
     static void encode(ArgumentEncoder&, const WebCore::ResourceResponse&);
-    static bool decode(ArgumentDecoder*, WebCore::ResourceResponse&);
+    static bool decode(ArgumentDecoder&, WebCore::ResourceResponse&);
     static void encodePlatformData(ArgumentEncoder&, const WebCore::ResourceResponse&);
-    static bool decodePlatformData(ArgumentDecoder*, WebCore::ResourceResponse&);
+    static bool decodePlatformData(ArgumentDecoder&, WebCore::ResourceResponse&);
 };
 
 template<> struct ArgumentCoder<WebCore::ResourceError> {
@@ -181,81 +181,81 @@ template<> struct ArgumentCoder<WebCore::ResourceError> {
 #endif
 
     static void encode(ArgumentEncoder&, const WebCore::ResourceError&);
-    static bool decode(ArgumentDecoder*, WebCore::ResourceError&);
+    static bool decode(ArgumentDecoder&, WebCore::ResourceError&);
     static void encodePlatformData(ArgumentEncoder&, const WebCore::ResourceError&);
-    static bool decodePlatformData(ArgumentDecoder*, WebCore::ResourceError&);
+    static bool decodePlatformData(ArgumentDecoder&, WebCore::ResourceError&);
 };
 
 template<> struct ArgumentCoder<WebCore::WindowFeatures> {
     static void encode(ArgumentEncoder&, const WebCore::WindowFeatures&);
-    static bool decode(ArgumentDecoder*, WebCore::WindowFeatures&);
+    static bool decode(ArgumentDecoder&, WebCore::WindowFeatures&);
 };
 
 template<> struct ArgumentCoder<WebCore::Color> {
     static void encode(ArgumentEncoder&, const WebCore::Color&);
-    static bool decode(ArgumentDecoder*, WebCore::Color&);
+    static bool decode(ArgumentDecoder&, WebCore::Color&);
 };
 
 #if PLATFORM(MAC)
 template<> struct ArgumentCoder<WebCore::KeypressCommand> {
     static void encode(ArgumentEncoder&, const WebCore::KeypressCommand&);
-    static bool decode(ArgumentDecoder*, WebCore::KeypressCommand&);
+    static bool decode(ArgumentDecoder&, WebCore::KeypressCommand&);
 };
 #endif
 
 template<> struct ArgumentCoder<WebCore::CompositionUnderline> {
     static void encode(ArgumentEncoder&, const WebCore::CompositionUnderline&);
-    static bool decode(ArgumentDecoder*, WebCore::CompositionUnderline&);
+    static bool decode(ArgumentDecoder&, WebCore::CompositionUnderline&);
 };
 
 template<> struct ArgumentCoder<WebCore::Cookie> {
     static void encode(ArgumentEncoder&, const WebCore::Cookie&);
-    static bool decode(ArgumentDecoder*, WebCore::Cookie&);
+    static bool decode(ArgumentDecoder&, WebCore::Cookie&);
 };
 
 template<> struct ArgumentCoder<WebCore::DatabaseDetails> {
     static void encode(ArgumentEncoder&, const WebCore::DatabaseDetails&);
-    static bool decode(ArgumentDecoder*, WebCore::DatabaseDetails&);
+    static bool decode(ArgumentDecoder&, WebCore::DatabaseDetails&);
 };
 
 template<> struct ArgumentCoder<WebCore::DictationAlternative> {
     static void encode(ArgumentEncoder&, const WebCore::DictationAlternative&);
-    static bool decode(ArgumentDecoder*, WebCore::DictationAlternative&);
+    static bool decode(ArgumentDecoder&, WebCore::DictationAlternative&);
 };
 
 template<> struct ArgumentCoder<WebCore::FileChooserSettings> {
     static void encode(ArgumentEncoder&, const WebCore::FileChooserSettings&);
-    static bool decode(ArgumentDecoder*, WebCore::FileChooserSettings&);
+    static bool decode(ArgumentDecoder&, WebCore::FileChooserSettings&);
 };
 
 template<> struct ArgumentCoder<WebCore::GrammarDetail> {
     static void encode(ArgumentEncoder&, const WebCore::GrammarDetail&);
-    static bool decode(ArgumentDecoder*, WebCore::GrammarDetail&);
+    static bool decode(ArgumentDecoder&, WebCore::GrammarDetail&);
 };
 
 template<> struct ArgumentCoder<WebCore::TextCheckingResult> {
     static void encode(ArgumentEncoder&, const WebCore::TextCheckingResult&);
-    static bool decode(ArgumentDecoder*, WebCore::TextCheckingResult&);
+    static bool decode(ArgumentDecoder&, WebCore::TextCheckingResult&);
 };
     
 template<> struct ArgumentCoder<WebCore::DragSession> {
     static void encode(ArgumentEncoder&, const WebCore::DragSession&);
-    static bool decode(ArgumentDecoder*, WebCore::DragSession&);
+    static bool decode(ArgumentDecoder&, WebCore::DragSession&);
 };
 
 template<> struct ArgumentCoder<WebCore::KURL> {
     static void encode(ArgumentEncoder&, const WebCore::KURL&);
-    static bool decode(ArgumentDecoder*, WebCore::KURL&);
+    static bool decode(ArgumentDecoder&, WebCore::KURL&);
 };
 
 template<> struct ArgumentCoder<WebCore::UserStyleSheet> {
     static void encode(ArgumentEncoder&, const WebCore::UserStyleSheet&);
-    static bool decode(ArgumentDecoder*, WebCore::UserStyleSheet&);
+    static bool decode(ArgumentDecoder&, WebCore::UserStyleSheet&);
 };
 
 template<> struct ArgumentCoder<WebCore::UserScript> {
     static void encode(ArgumentEncoder&, const WebCore::UserScript&);
-    static bool decode(ArgumentDecoder*, WebCore::UserScript&);
+    static bool decode(ArgumentDecoder&, WebCore::UserScript&);
 };
 
 } // namespace CoreIPC
index df3ed4e..f67d130 100644 (file)
@@ -53,13 +53,13 @@ void WebEvent::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_timestamp;
 }
 
-bool WebEvent::decode(CoreIPC::ArgumentDecoder* decoder, WebEvent& result)
+bool WebEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebEvent& result)
 {
-    if (!decoder->decode(result.m_type))
+    if (!decoder.decode(result.m_type))
         return false;
-    if (!decoder->decode(result.m_modifiers))
+    if (!decoder.decode(result.m_modifiers))
         return false;
-    if (!decoder->decode(result.m_timestamp))
+    if (!decoder.decode(result.m_timestamp))
         return false;
     return true;
 }
index 83e6216..0876f6d 100644 (file)
@@ -104,7 +104,7 @@ protected:
     WebEvent(Type, Modifiers, double timestamp);
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebEvent&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebEvent&);
 
 private:
     uint32_t m_type; // Type
@@ -135,7 +135,7 @@ public:
     int32_t clickCount() const { return m_clickCount; }
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebMouseEvent&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebMouseEvent&);
 
 private:
     static bool isMouseEventType(Type);
@@ -191,7 +191,7 @@ public:
 #endif
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebWheelEvent&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebWheelEvent&);
 
 private:
     static bool isWheelEventType(Type);
@@ -229,7 +229,7 @@ public:
     bool isSystemKey() const { return m_isSystemKey; }
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebKeyboardEvent&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebKeyboardEvent&);
 
     static bool isKeyboardEventType(Type);
 
@@ -260,7 +260,7 @@ public:
     const WebCore::FloatPoint delta() const { return m_delta; }
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebGestureEvent&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebGestureEvent&);
 
 private:
     static bool isGestureEventType(Type);
@@ -305,7 +305,7 @@ public:
     void setState(TouchPointState state) { m_state = state; }
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebPlatformTouchPoint&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebPlatformTouchPoint&);
 
 private:
     uint32_t m_id;
@@ -328,7 +328,7 @@ public:
     const Vector<WebPlatformTouchPoint>& touchPoints() const { return m_touchPoints; }
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebTouchEvent&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebTouchEvent&);
   
 private:
     static bool isTouchEventType(Type);
index 645e8c0..84a0491 100644 (file)
@@ -56,7 +56,7 @@ void WebGeolocationPosition::Data::encode(CoreIPC::ArgumentEncoder& encoder) con
     CoreIPC::SimpleArgumentCoder<WebGeolocationPosition::Data>::encode(encoder, *this);
 }
 
-bool WebGeolocationPosition::Data::decode(CoreIPC::ArgumentDecoder* decoder, Data& data)
+bool WebGeolocationPosition::Data::decode(CoreIPC::ArgumentDecoder& decoder, Data& data)
 {
     return CoreIPC::SimpleArgumentCoder<WebGeolocationPosition::Data>::decode(decoder, data);
 }
index 52ebed9..f9e28a5 100644 (file)
@@ -39,7 +39,7 @@ public:
 
     struct Data {
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, Data&);
+        static bool decode(CoreIPC::ArgumentDecoder&, Data&);
 
         double timestamp;
         double latitude;
index a9089e2..138c8f1 100644 (file)
@@ -63,17 +63,17 @@ void WebGestureEvent::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_delta;
 }
 
-bool WebGestureEvent::decode(CoreIPC::ArgumentDecoder* decoder, WebGestureEvent& t)
+bool WebGestureEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebGestureEvent& t)
 {
     if (!WebEvent::decode(decoder, t))
         return false;
-    if (!decoder->decode(t.m_position))
+    if (!decoder.decode(t.m_position))
         return false;
-    if (!decoder->decode(t.m_globalPosition))
+    if (!decoder.decode(t.m_globalPosition))
         return false;
-    if (!decoder->decode(t.m_area))
+    if (!decoder.decode(t.m_area))
         return false;
-    if (!decoder->decode(t.m_delta))
+    if (!decoder.decode(t.m_delta))
         return false;
     return true;
 }
index 1bcf951..1c61c38 100644 (file)
@@ -47,17 +47,17 @@ void WebHitTestResult::Data::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << isScrollbar;
 }
 
-bool WebHitTestResult::Data::decode(CoreIPC::ArgumentDecoder* decoder, WebHitTestResult::Data& hitTestResultData)
+bool WebHitTestResult::Data::decode(CoreIPC::ArgumentDecoder& decoder, WebHitTestResult::Data& hitTestResultData)
 {
-    if (!decoder->decode(hitTestResultData.absoluteImageURL)
-        || !decoder->decode(hitTestResultData.absolutePDFURL)
-        || !decoder->decode(hitTestResultData.absoluteLinkURL)
-        || !decoder->decode(hitTestResultData.absoluteMediaURL)
-        || !decoder->decode(hitTestResultData.linkLabel)
-        || !decoder->decode(hitTestResultData.linkTitle)
-        || !decoder->decode(hitTestResultData.isContentEditable)
-        || !decoder->decode(hitTestResultData.elementBoundingBox)
-        || !decoder->decode(hitTestResultData.isScrollbar))
+    if (!decoder.decode(hitTestResultData.absoluteImageURL)
+        || !decoder.decode(hitTestResultData.absolutePDFURL)
+        || !decoder.decode(hitTestResultData.absoluteLinkURL)
+        || !decoder.decode(hitTestResultData.absoluteMediaURL)
+        || !decoder.decode(hitTestResultData.linkLabel)
+        || !decoder.decode(hitTestResultData.linkTitle)
+        || !decoder.decode(hitTestResultData.isContentEditable)
+        || !decoder.decode(hitTestResultData.elementBoundingBox)
+        || !decoder.decode(hitTestResultData.isScrollbar))
         return false;
 
     return true;
index 7e6e0a9..8f2aca7 100644 (file)
@@ -89,7 +89,7 @@ public:
         }
 
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, WebHitTestResult::Data&);
+        static bool decode(CoreIPC::ArgumentDecoder&, WebHitTestResult::Data&);
     };
 
     static PassRefPtr<WebHitTestResult> create(const WebHitTestResult::Data&);
index 02056ff..53ab16b 100644 (file)
@@ -60,28 +60,28 @@ void WebKeyboardEvent::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_isSystemKey;
 }
 
-bool WebKeyboardEvent::decode(CoreIPC::ArgumentDecoder* decoder, WebKeyboardEvent& result)
+bool WebKeyboardEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebKeyboardEvent& result)
 {
     if (!WebEvent::decode(decoder, result))
         return false;
 
-    if (!decoder->decode(result.m_text))
+    if (!decoder.decode(result.m_text))
         return false;
-    if (!decoder->decode(result.m_unmodifiedText))
+    if (!decoder.decode(result.m_unmodifiedText))
         return false;
-    if (!decoder->decode(result.m_keyIdentifier))
+    if (!decoder.decode(result.m_keyIdentifier))
         return false;
-    if (!decoder->decode(result.m_windowsVirtualKeyCode))
+    if (!decoder.decode(result.m_windowsVirtualKeyCode))
         return false;
-    if (!decoder->decode(result.m_nativeVirtualKeyCode))
+    if (!decoder.decode(result.m_nativeVirtualKeyCode))
         return false;
-    if (!decoder->decode(result.m_macCharCode))
+    if (!decoder.decode(result.m_macCharCode))
         return false;
-    if (!decoder->decode(result.m_isAutoRepeat))
+    if (!decoder.decode(result.m_isAutoRepeat))
         return false;
-    if (!decoder->decode(result.m_isKeypad))
+    if (!decoder.decode(result.m_isKeypad))
         return false;
-    if (!decoder->decode(result.m_isSystemKey))
+    if (!decoder.decode(result.m_isSystemKey))
         return false;
 
     return true;
index 049374b..f259d71 100644 (file)
@@ -69,24 +69,24 @@ void WebMouseEvent::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_clickCount;
 }
 
-bool WebMouseEvent::decode(CoreIPC::ArgumentDecoder* decoder, WebMouseEvent& result)
+bool WebMouseEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebMouseEvent& result)
 {
     if (!WebEvent::decode(decoder, result))
         return false;
 
-    if (!decoder->decode(result.m_button))
+    if (!decoder.decode(result.m_button))
         return false;
-    if (!decoder->decode(result.m_position))
+    if (!decoder.decode(result.m_position))
         return false;
-    if (!decoder->decode(result.m_globalPosition))
+    if (!decoder.decode(result.m_globalPosition))
         return false;
-    if (!decoder->decode(result.m_deltaX))
+    if (!decoder.decode(result.m_deltaX))
         return false;
-    if (!decoder->decode(result.m_deltaY))
+    if (!decoder.decode(result.m_deltaY))
         return false;
-    if (!decoder->decode(result.m_deltaZ))
+    if (!decoder.decode(result.m_deltaZ))
         return false;
-    if (!decoder->decode(result.m_clickCount))
+    if (!decoder.decode(result.m_clickCount))
         return false;
 
     return true;
index f521a58..ca9aa9d 100644 (file)
@@ -42,13 +42,13 @@ struct WebNavigationDataStore {
         encoder << originalRequest;
     }
 
-    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebNavigationDataStore& store)
+    static bool decode(CoreIPC::ArgumentDecoder& decoder, WebNavigationDataStore& store)
     {
-        if (!decoder->decode(store.url))
+        if (!decoder.decode(store.url))
             return false;
-        if (!decoder->decode(store.title))
+        if (!decoder.decode(store.title))
             return false;
-        if (!decoder->decode(store.originalRequest))
+        if (!decoder.decode(store.originalRequest))
             return false;
         return true;
     }
index e925db3..a6f2d01 100644 (file)
@@ -66,65 +66,65 @@ void WebPageCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool WebPageCreationParameters::decode(CoreIPC::ArgumentDecoder* decoder, WebPageCreationParameters& parameters)
+bool WebPageCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, WebPageCreationParameters& parameters)
 {
-    if (!decoder->decode(parameters.viewSize))
+    if (!decoder.decode(parameters.viewSize))
         return false;
-    if (!decoder->decode(parameters.isActive))
+    if (!decoder.decode(parameters.isActive))
         return false;
-    if (!decoder->decode(parameters.isFocused))
+    if (!decoder.decode(parameters.isFocused))
         return false;
-    if (!decoder->decode(parameters.isVisible))
+    if (!decoder.decode(parameters.isVisible))
         return false;
-    if (!decoder->decode(parameters.isInWindow))
+    if (!decoder.decode(parameters.isInWindow))
         return false;
-    if (!decoder->decode(parameters.store))
+    if (!decoder.decode(parameters.store))
         return false;
-    if (!decoder->decodeEnum(parameters.drawingAreaType))
+    if (!decoder.decodeEnum(parameters.drawingAreaType))
         return false;
-    if (!decoder->decode(parameters.pageGroupData))
+    if (!decoder.decode(parameters.pageGroupData))
         return false;
-    if (!decoder->decode(parameters.drawsBackground))
+    if (!decoder.decode(parameters.drawsBackground))
         return false;
-    if (!decoder->decode(parameters.drawsTransparentBackground))
+    if (!decoder.decode(parameters.drawsTransparentBackground))
         return false;
-    if (!decoder->decode(parameters.areMemoryCacheClientCallsEnabled))
+    if (!decoder.decode(parameters.areMemoryCacheClientCallsEnabled))
         return false;
-    if (!decoder->decode(parameters.useFixedLayout))
+    if (!decoder.decode(parameters.useFixedLayout))
         return false;
-    if (!decoder->decode(parameters.fixedLayoutSize))
+    if (!decoder.decode(parameters.fixedLayoutSize))
         return false;
-    if (!decoder->decodeEnum(parameters.paginationMode))
+    if (!decoder.decodeEnum(parameters.paginationMode))
         return false;
-    if (!decoder->decode(parameters.paginationBehavesLikeColumns))
+    if (!decoder.decode(parameters.paginationBehavesLikeColumns))
         return false;
-    if (!decoder->decode(parameters.pageLength))
+    if (!decoder.decode(parameters.pageLength))
         return false;
-    if (!decoder->decode(parameters.gapBetweenPages))
+    if (!decoder.decode(parameters.gapBetweenPages))
         return false;
-    if (!decoder->decode(parameters.userAgent))
+    if (!decoder.decode(parameters.userAgent))
         return false;
-    if (!decoder->decode(parameters.sessionState))
+    if (!decoder.decode(parameters.sessionState))
         return false;
-    if (!decoder->decode(parameters.highestUsedBackForwardItemID))
+    if (!decoder.decode(parameters.highestUsedBackForwardItemID))
         return false;
-    if (!decoder->decode(parameters.canRunBeforeUnloadConfirmPanel))
+    if (!decoder.decode(parameters.canRunBeforeUnloadConfirmPanel))
         return false;
-    if (!decoder->decode(parameters.canRunModal))
+    if (!decoder.decode(parameters.canRunModal))
         return false;
-    if (!decoder->decode(parameters.deviceScaleFactor))
+    if (!decoder.decode(parameters.deviceScaleFactor))
         return false;
-    if (!decoder->decode(parameters.mediaVolume))
+    if (!decoder.decode(parameters.mediaVolume))
         return false;
-    if (!decoder->decode(parameters.mayStartMediaWhenInWindow))
+    if (!decoder.decode(parameters.mayStartMediaWhenInWindow))
         return false;
 
 #if PLATFORM(MAC)
-    if (!decoder->decode(parameters.isSmartInsertDeleteEnabled))
+    if (!decoder.decode(parameters.isSmartInsertDeleteEnabled))
         return false;
-    if (!decoder->decodeEnum(parameters.layerHostingMode))
+    if (!decoder.decodeEnum(parameters.layerHostingMode))
         return false;
-    if (!decoder->decode(parameters.colorSpace))
+    if (!decoder.decode(parameters.colorSpace))
         return false;
 #endif
 
index 5803cd0..906aebe 100644 (file)
@@ -46,7 +46,7 @@ namespace WebKit {
 
 struct WebPageCreationParameters {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebPageCreationParameters&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebPageCreationParameters&);
 
     WebCore::IntSize viewSize;
 
index 871b4d1..3b5ef2a 100644 (file)
@@ -40,19 +40,19 @@ void WebPageGroupData::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << userScripts;
 }
 
-bool WebPageGroupData::decode(CoreIPC::ArgumentDecoder* decoder, WebPageGroupData& data)
+bool WebPageGroupData::decode(CoreIPC::ArgumentDecoder& decoder, WebPageGroupData& data)
 {
-    if (!decoder->decode(data.identifer))
+    if (!decoder.decode(data.identifer))
         return false;
-    if (!decoder->decode(data.pageGroupID))
+    if (!decoder.decode(data.pageGroupID))
         return false;
-    if (!decoder->decode(data.visibleToInjectedBundle))
+    if (!decoder.decode(data.visibleToInjectedBundle))
         return false;
-    if (!decoder->decode(data.visibleToHistoryClient))
+    if (!decoder.decode(data.visibleToHistoryClient))
         return false;
-    if (!decoder->decode(data.userStyleSheets))
+    if (!decoder.decode(data.userStyleSheets))
         return false;
-    if (!decoder->decode(data.userScripts))
+    if (!decoder.decode(data.userScripts))
         return false;
     return true;
 }
index 4dbfd2c..37e3e61 100644 (file)
@@ -40,7 +40,7 @@ namespace WebKit {
 
 struct WebPageGroupData {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebPageGroupData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebPageGroupData&);
 
     String identifer;
     uint64_t pageGroupID;
index bae8d65..f152013 100644 (file)
@@ -68,21 +68,21 @@ void WebPlatformTouchPoint::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_force;
 }
 
-bool WebPlatformTouchPoint::decode(CoreIPC::ArgumentDecoder* decoder, WebPlatformTouchPoint& result)
+bool WebPlatformTouchPoint::decode(CoreIPC::ArgumentDecoder& decoder, WebPlatformTouchPoint& result)
 {
-    if (!decoder->decode(result.m_id))
+    if (!decoder.decode(result.m_id))
         return false;
-    if (!decoder->decode(result.m_state))
+    if (!decoder.decode(result.m_state))
         return false;
-    if (!decoder->decode(result.m_screenPosition))
+    if (!decoder.decode(result.m_screenPosition))
         return false;
-    if (!decoder->decode(result.m_position))
+    if (!decoder.decode(result.m_position))
         return false;
-    if (!decoder->decode(result.m_radius))
+    if (!decoder.decode(result.m_radius))
         return false;
-    if (!decoder->decode(result.m_rotationAngle))
+    if (!decoder.decode(result.m_rotationAngle))
         return false;
-    if (!decoder->decode(result.m_force))
+    if (!decoder.decode(result.m_force))
         return false;
 
     return true;
index bbe48fb..89711ab 100644 (file)
@@ -79,42 +79,42 @@ void WebPopupItem::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_isSelected;
 }
 
-bool WebPopupItem::decode(CoreIPC::ArgumentDecoder* decoder, WebPopupItem& item)
+bool WebPopupItem::decode(CoreIPC::ArgumentDecoder& decoder, WebPopupItem& item)
 {
     Type type;
-    if (!decoder->decodeEnum(type))
+    if (!decoder.decodeEnum(type))
         return false;
 
     String text;
-    if (!decoder->decode(text))
+    if (!decoder.decode(text))
         return false;
     
     TextDirection textDirection;
-    if (!decoder->decodeEnum(textDirection))
+    if (!decoder.decodeEnum(textDirection))
         return false;
 
     bool hasTextDirectionOverride;
-    if (!decoder->decode(hasTextDirectionOverride))
+    if (!decoder.decode(hasTextDirectionOverride))
         return false;
 
     String toolTip;
-    if (!decoder->decode(toolTip))
+    if (!decoder.decode(toolTip))
         return false;
 
     String accessibilityText;
-    if (!decoder->decode(accessibilityText))
+    if (!decoder.decode(accessibilityText))
         return false;
 
     bool isEnabled;
-    if (!decoder->decode(isEnabled))
+    if (!decoder.decode(isEnabled))
         return false;
 
     bool isLabel;
-    if (!decoder->decode(isLabel))
+    if (!decoder.decode(isLabel))
         return false;
 
     bool isSelected;
-    if (!decoder->decode(isSelected))
+    if (!decoder.decode(isSelected))
         return false;
 
     item = WebPopupItem(type, text, textDirection, hasTextDirectionOverride, toolTip, accessibilityText, isEnabled, isLabel, isSelected);
index 6f8ecb1..884ee9e 100644 (file)
@@ -47,7 +47,7 @@ struct WebPopupItem {
     WebPopupItem(Type, const String& text, WebCore::TextDirection, bool hasTextDirectionOverride, const String& toolTip, const String& accessibilityText, bool isEnabled, bool isLabel, bool isSelected);
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebPopupItem&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebPopupItem&);
 
     Type m_type;
     String m_text;
index e73c0f6..d050e57 100644 (file)
@@ -68,17 +68,17 @@ void WebPreferencesStore::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_floatValues;
 }
 
-bool WebPreferencesStore::decode(CoreIPC::ArgumentDecoder* decoder, WebPreferencesStore& result)
+bool WebPreferencesStore::decode(CoreIPC::ArgumentDecoder& decoder, WebPreferencesStore& result)
 {
-    if (!decoder->decode(result.m_stringValues))
+    if (!decoder.decode(result.m_stringValues))
         return false;
-    if (!decoder->decode(result.m_boolValues))
+    if (!decoder.decode(result.m_boolValues))
         return false;
-    if (!decoder->decode(result.m_uint32Values))
+    if (!decoder.decode(result.m_uint32Values))
         return false;
-    if (!decoder->decode(result.m_doubleValues))
+    if (!decoder.decode(result.m_doubleValues))
         return false;
-    if (!decoder->decode(result.m_floatValues))
+    if (!decoder.decode(result.m_floatValues))
         return false;
     return true;
 }
index a03e889..8f4e56a 100644 (file)
@@ -218,7 +218,7 @@ struct WebPreferencesStore {
     WebPreferencesStore();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebPreferencesStore&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebPreferencesStore&);
 
     // NOTE: The getters in this class have non-standard names to aid in the use of the preference macros.
 
index dc127ef..83543c1 100644 (file)
@@ -113,117 +113,117 @@ void WebProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder) con
     encoder << plugInAutoStartOrigins;
 }
 
-bool WebProcessCreationParameters::decode(CoreIPC::ArgumentDecoder* decoder, WebProcessCreationParameters& parameters)
+bool WebProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, WebProcessCreationParameters& parameters)
 {
-    if (!decoder->decode(parameters.injectedBundlePath))
+    if (!decoder.decode(parameters.injectedBundlePath))
         return false;
-    if (!decoder->decode(parameters.injectedBundlePathExtensionHandle))
+    if (!decoder.decode(parameters.injectedBundlePathExtensionHandle))
         return false;
-    if (!decoder->decode(parameters.applicationCacheDirectory))
+    if (!decoder.decode(parameters.applicationCacheDirectory))
         return false;
-    if (!decoder->decode(parameters.applicationCacheDirectoryExtensionHandle))
+    if (!decoder.decode(parameters.applicationCacheDirectoryExtensionHandle))
         return false;
-    if (!decoder->decode(parameters.databaseDirectory))
+    if (!decoder.decode(parameters.databaseDirectory))
         return false;
-    if (!decoder->decode(parameters.databaseDirectoryExtensionHandle))
+    if (!decoder.decode(parameters.databaseDirectoryExtensionHandle))
         return false;
-    if (!decoder->decode(parameters.localStorageDirectory))
+    if (!decoder.decode(parameters.localStorageDirectory))
         return false;
-    if (!decoder->decode(parameters.localStorageDirectoryExtensionHandle))
+    if (!decoder.decode(parameters.localStorageDirectoryExtensionHandle))
         return false;
-    if (!decoder->decode(parameters.diskCacheDirectory))
+    if (!decoder.decode(parameters.diskCacheDirectory))
         return false;
-    if (!decoder->decode(parameters.diskCacheDirectoryExtensionHandle))
+    if (!decoder.decode(parameters.diskCacheDirectoryExtensionHandle))
         return false;
-    if (!decoder->decode(parameters.cookieStorageDirectory))
+    if (!decoder.decode(parameters.cookieStorageDirectory))
         return false;
-    if (!decoder->decode(parameters.cookieStorageDirectoryExtensionHandle))
+    if (!decoder.decode(parameters.cookieStorageDirectoryExtensionHandle))
         return false;
-    if (!decoder->decode(parameters.urlSchemesRegistererdAsEmptyDocument))
+    if (!decoder.decode(parameters.urlSchemesRegistererdAsEmptyDocument))
         return false;
-    if (!decoder->decode(parameters.urlSchemesRegisteredAsSecure))
+    if (!decoder.decode(parameters.urlSchemesRegisteredAsSecure))
         return false;
-    if (!decoder->decode(parameters.urlSchemesForWhichDomainRelaxationIsForbidden))
+    if (!decoder.decode(parameters.urlSchemesForWhichDomainRelaxationIsForbidden))
         return false;
-    if (!decoder->decode(parameters.urlSchemesRegisteredAsLocal))
+    if (!decoder.decode(parameters.urlSchemesRegisteredAsLocal))
         return false;
-    if (!decoder->decode(parameters.urlSchemesRegisteredAsNoAccess))
+    if (!decoder.decode(parameters.urlSchemesRegisteredAsNoAccess))
         return false;
-    if (!decoder->decode(parameters.urlSchemesRegisteredAsDisplayIsolated))
+    if (!decoder.decode(parameters.urlSchemesRegisteredAsDisplayIsolated))
         return false;
-    if (!decoder->decode(parameters.urlSchemesRegisteredAsCORSEnabled))
+    if (!decoder.decode(parameters.urlSchemesRegisteredAsCORSEnabled))
         return false;
 #if ENABLE(CUSTOM_PROTOCOLS)
-    if (!decoder->decode(parameters.urlSchemesRegisteredForCustomProtocols))
+    if (!decoder.decode(parameters.urlSchemesRegisteredForCustomProtocols))
         return false;
 #endif
 #if USE(SOUP)
-    if (!decoder->decode(parameters.urlSchemesRegistered))
+    if (!decoder.decode(parameters.urlSchemesRegistered))
         return false;
-    if (!decoder->decode(parameters.cookiePersistentStoragePath))
+    if (!decoder.decode(parameters.cookiePersistentStoragePath))
         return false;
-    if (!decoder->decode(parameters.cookiePersistentStorageType))
+    if (!decoder.decode(parameters.cookiePersistentStorageType))
         return false;
-    if (!decoder->decodeEnum(parameters.cookieAcceptPolicy))
+    if (!decoder.decodeEnum(parameters.cookieAcceptPolicy))
         return false;
-    if (!decoder->decode(parameters.ignoreTLSErrors))
+    if (!decoder.decode(parameters.ignoreTLSErrors))
         return false;
 #endif
-    if (!decoder->decodeEnum(parameters.cacheModel))
+    if (!decoder.decodeEnum(parameters.cacheModel))
         return false;
-    if (!decoder->decode(parameters.shouldTrackVisitedLinks))
+    if (!decoder.decode(parameters.shouldTrackVisitedLinks))
         return false;
-    if (!decoder->decode(parameters.shouldAlwaysUseComplexTextCodePath))
+    if (!decoder.decode(parameters.shouldAlwaysUseComplexTextCodePath))
         return false;
-    if (!decoder->decode(parameters.shouldUseFontSmoothing))
+    if (!decoder.decode(parameters.shouldUseFontSmoothing))
         return false;
-    if (!decoder->decode(parameters.iconDatabaseEnabled))
+    if (!decoder.decode(parameters.iconDatabaseEnabled))
         return false;
-    if (!decoder->decode(parameters.terminationTimeout))
+    if (!decoder.decode(parameters.terminationTimeout))
         return false;
-    if (!decoder->decode(parameters.languages))
+    if (!decoder.decode(parameters.languages))
         return false;
-    if (!decoder->decode(parameters.textCheckerState))
+    if (!decoder.decode(parameters.textCheckerState))
         return false;
-    if (!decoder->decode(parameters.fullKeyboardAccessEnabled))
+    if (!decoder.decode(parameters.fullKeyboardAccessEnabled))
         return false;
-    if (!decoder->decode(parameters.defaultRequestTimeoutInterval))
+    if (!decoder.decode(parameters.defaultRequestTimeoutInterval))
         return false;
 #if PLATFORM(MAC) || USE(CFNETWORK)
-    if (!decoder->decode(parameters.uiProcessBundleIdentifier))
+    if (!decoder.decode(parameters.uiProcessBundleIdentifier))
         return false;
 #endif
 
 #if PLATFORM(MAC)
-    if (!decoder->decode(parameters.presenterApplicationPid))
+    if (!decoder.decode(parameters.presenterApplicationPid))
         return false;
-    if (!decoder->decode(parameters.nsURLCacheMemoryCapacity))
+    if (!decoder.decode(parameters.nsURLCacheMemoryCapacity))
         return false;
-    if (!decoder->decode(parameters.nsURLCacheDiskCapacity))
+    if (!decoder.decode(parameters.nsURLCacheDiskCapacity))
         return false;
-    if (!decoder->decode(parameters.acceleratedCompositingPort))
+    if (!decoder.decode(parameters.acceleratedCompositingPort))
         return false;
-    if (!decoder->decode(parameters.uiProcessBundleResourcePath))
+    if (!decoder.decode(parameters.uiProcessBundleResourcePath))
         return false;
-    if (!decoder->decode(parameters.uiProcessBundleResourcePathExtensionHandle))
+    if (!decoder.decode(parameters.uiProcessBundleResourcePathExtensionHandle))
         return false;
-    if (!decoder->decode(parameters.shouldForceScreenFontSubstitution))
+    if (!decoder.decode(parameters.shouldForceScreenFontSubstitution))
         return false;
-    if (!decoder->decode(parameters.shouldEnableKerningAndLigaturesByDefault))
+    if (!decoder.decode(parameters.shouldEnableKerningAndLigaturesByDefault))
         return false;
 #endif
 
 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
-    if (!decoder->decode(parameters.notificationPermissions))
+    if (!decoder.decode(parameters.notificationPermissions))
         return false;
 #endif
 
 #if ENABLE(NETWORK_PROCESS)
-    if (!decoder->decode(parameters.usesNetworkProcess))
+    if (!decoder.decode(parameters.usesNetworkProcess))
         return false;
 #endif
 
-    if (!decoder->decode(parameters.plugInAutoStartOrigins))
+    if (!decoder.decode(parameters.plugInAutoStartOrigins))
         return false;
 
     return true;
index cf0ec33..3dbc523 100644 (file)
@@ -53,7 +53,7 @@ struct WebProcessCreationParameters {
     WebProcessCreationParameters();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, WebProcessCreationParameters&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebProcessCreationParameters&);
 
     String injectedBundlePath;
     SandboxExtension::Handle injectedBundlePathExtensionHandle;
index 1f7e9f7..05b5fe5 100644 (file)
@@ -47,12 +47,12 @@ void WebTouchEvent::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_touchPoints;
 }
 
-bool WebTouchEvent::decode(CoreIPC::ArgumentDecoder* decoder, WebTouchEvent& result)
+bool WebTouchEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebTouchEvent& result)
 {
     if (!WebEvent::decode(decoder, result))
         return false;
 
-    if (!decoder->decode(result.m_touchPoints))
+    if (!decoder.decode(result.m_touchPoints))
         return false;
 
     return true;
index 3bd19f4..0cd7216 100644 (file)
@@ -88,32 +88,32 @@ void WebWheelEvent::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool WebWheelEvent::decode(CoreIPC::ArgumentDecoder* decoder, WebWheelEvent& t)
+bool WebWheelEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebWheelEvent& t)
 {
     if (!WebEvent::decode(decoder, t))
         return false;
-    if (!decoder->decode(t.m_position))
+    if (!decoder.decode(t.m_position))
         return false;
-    if (!decoder->decode(t.m_globalPosition))
+    if (!decoder.decode(t.m_globalPosition))
         return false;
-    if (!decoder->decode(t.m_delta))
+    if (!decoder.decode(t.m_delta))
         return false;
-    if (!decoder->decode(t.m_wheelTicks))
+    if (!decoder.decode(t.m_wheelTicks))
         return false;
-    if (!decoder->decode(t.m_granularity))
+    if (!decoder.decode(t.m_granularity))
         return false;
-    if (!decoder->decode(t.m_directionInvertedFromDevice))
+    if (!decoder.decode(t.m_directionInvertedFromDevice))
         return false;
 #if PLATFORM(MAC)
-    if (!decoder->decode(t.m_phase))
+    if (!decoder.decode(t.m_phase))
         return false;
-    if (!decoder->decode(t.m_momentumPhase))
+    if (!decoder.decode(t.m_momentumPhase))
         return false;
-    if (!decoder->decode(t.m_hasPreciseScrollingDeltas))
+    if (!decoder.decode(t.m_hasPreciseScrollingDeltas))
         return false;
-    if (!decoder->decode(t.m_scrollCount))
+    if (!decoder.decode(t.m_scrollCount))
         return false;
-    if (!decoder->decode(t.m_unacceleratedScrollingDelta))
+    if (!decoder.decode(t.m_unacceleratedScrollingDelta))
         return false;
 #endif
     return true;
index 8761eda..573d2dd 100644 (file)
@@ -147,10 +147,10 @@ void encode(ArgumentEncoder& encoder, CFTypeRef typeRef)
     ASSERT_NOT_REACHED();
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFTypeRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFTypeRef>& result)
 {
     CFType type;
-    if (!decoder->decodeEnum(type))
+    if (!decoder.decodeEnum(type))
         return false;
 
     switch (type) {
@@ -256,10 +256,10 @@ void encode(ArgumentEncoder& encoder, CFArrayRef array)
     }
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFArrayRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFArrayRef>& result)
 {
     uint64_t size;
-    if (!decoder->decode(size))
+    if (!decoder.decode(size))
         return false;
 
     RetainPtr<CFMutableArrayRef> array(AdoptCF, CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));
@@ -281,10 +281,10 @@ void encode(ArgumentEncoder& encoder, CFBooleanRef boolean)
     encoder << static_cast<bool>(CFBooleanGetValue(boolean));
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFBooleanRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFBooleanRef>& result)
 {
     bool boolean;
-    if (!decoder->decode(boolean))
+    if (!decoder.decode(boolean))
         return false;
 
     result.adoptCF(boolean ? kCFBooleanTrue : kCFBooleanFalse);
@@ -299,10 +299,10 @@ void encode(ArgumentEncoder& encoder, CFDataRef data)
     encoder << CoreIPC::DataReference(bytePtr, length);
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFDataRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFDataRef>& result)
 {
     CoreIPC::DataReference dataReference;
-    if (!decoder->decode(dataReference))
+    if (!decoder.decode(dataReference))
         return false;
 
     result.adoptCF(CFDataCreate(0, dataReference.data(), dataReference.size()));
@@ -314,10 +314,10 @@ void encode(ArgumentEncoder& encoder, CFDateRef date)
     encoder << static_cast<double>(CFDateGetAbsoluteTime(date));
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFDateRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFDateRef>& result)
 {
     double absoluteTime;
-    if (!decoder->decode(absoluteTime))
+    if (!decoder.decode(absoluteTime))
         return false;
 
     result.adoptCF(CFDateCreate(0, absoluteTime));
@@ -348,10 +348,10 @@ void encode(ArgumentEncoder& encoder, CFDictionaryRef dictionary)
     }
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFDictionaryRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFDictionaryRef>& result)
 {
     uint64_t size;
-    if (!decoder->decode(size))
+    if (!decoder.decode(size))
         return false;
 
     RetainPtr<CFMutableDictionaryRef> dictionary(AdoptCF, CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
@@ -432,14 +432,14 @@ static size_t sizeForNumberType(CFNumberType numberType)
     return 0;
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFNumberRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFNumberRef>& result)
 {
     CFNumberType numberType;
-    if (!decoder->decodeEnum(numberType))
+    if (!decoder.decodeEnum(numberType))
         return false;
 
     CoreIPC::DataReference dataReference;
-    if (!decoder->decode(dataReference))
+    if (!decoder.decode(dataReference))
         return false;
 
     size_t neededBufferSize = sizeForNumberType(numberType);
@@ -472,17 +472,17 @@ void encode(ArgumentEncoder& encoder, CFStringRef string)
     encoder << CoreIPC::DataReference(buffer);
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFStringRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFStringRef>& result)
 {
     CFStringEncoding encoding;
-    if (!decoder->decodeEnum(encoding))
+    if (!decoder.decodeEnum(encoding))
         return false;
 
     if (!CFStringIsEncodingAvailable(encoding))
         return false;
     
     CoreIPC::DataReference dataReference;
-    if (!decoder->decode(dataReference))
+    if (!decoder.decode(dataReference))
         return false;
 
     CFStringRef string = CFStringCreateWithBytes(0, dataReference.data(), dataReference.size(), encoding, false);
@@ -503,11 +503,11 @@ void encode(ArgumentEncoder& encoder, CFURLRef url)
     encode(encoder, CFURLGetString(url));
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<CFURLRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<CFURLRef>& result)
 {
     RetainPtr<CFURLRef> baseURL;
     bool hasBaseURL;
-    if (!decoder->decode(hasBaseURL))
+    if (!decoder.decode(hasBaseURL))
         return false;
     if (hasBaseURL) {
         if (!decode(decoder, baseURL))
@@ -543,7 +543,7 @@ void encode(ArgumentEncoder& encoder, SecCertificateRef certificate)
     encode(encoder, data.get());
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<SecCertificateRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<SecCertificateRef>& result)
 {
     RetainPtr<CFDataRef> data;
     if (!decode(decoder, data))
@@ -562,7 +562,7 @@ void encode(ArgumentEncoder& encoder, SecKeychainItemRef keychainItem)
     }
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<SecKeychainItemRef>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<SecKeychainItemRef>& result)
 {
     RetainPtr<CFDataRef> data;
     if (!CoreIPC::decode(decoder, data))
index 514fa86..5fb034e 100644 (file)
@@ -40,48 +40,48 @@ class ArgumentDecoder;
 
 // CFArrayRef
 void encode(ArgumentEncoder&, CFArrayRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFArrayRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFArrayRef>& result);
 
 // CFBooleanRef
 void encode(ArgumentEncoder&, CFBooleanRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFBooleanRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFBooleanRef>& result);
 
 // CFDataRef
 void encode(ArgumentEncoder&, CFDataRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFDataRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFDataRef>& result);
 
 // CFDateRef
 void encode(ArgumentEncoder&, CFDateRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFDateRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFDateRef>& result);
 
 // CFDictionaryRef
 void encode(ArgumentEncoder&, CFDictionaryRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFDictionaryRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFDictionaryRef>& result);
 
 // CFNumberRef
 void encode(ArgumentEncoder&, CFNumberRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFNumberRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFNumberRef>& result);
 
 // CFStringRef
 void encode(ArgumentEncoder&, CFStringRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFStringRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFStringRef>& result);
 
 // CFTypeRef
 void encode(ArgumentEncoder&, CFTypeRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFTypeRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFTypeRef>& result);
 
 // CFURLRef
 void encode(ArgumentEncoder&, CFURLRef);
-bool decode(ArgumentDecoder*, RetainPtr<CFURLRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<CFURLRef>& result);
 
 #if USE(SECURITY_FRAMEWORK)
 // SecCertificateRef
 void encode(ArgumentEncoder&, SecCertificateRef);
-bool decode(ArgumentDecoder*, RetainPtr<SecCertificateRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<SecCertificateRef>& result);
 
 // SecKeychainItemRef
 void encode(ArgumentEncoder&, SecKeychainItemRef);
-bool decode(ArgumentDecoder*, RetainPtr<SecKeychainItemRef>& result);
+bool decode(ArgumentDecoder&, RetainPtr<SecKeychainItemRef>& result);
 #endif
 
 CFTypeRef tokenNullTypeRef();
index 07c4060..dc0f665 100644 (file)
@@ -35,47 +35,47 @@ class ArgumentDecoder;
 
 // id
 void encode(ArgumentEncoder&, id);
-bool decode(ArgumentDecoder*, RetainPtr<id>&);
+bool decode(ArgumentDecoder&, RetainPtr<id>&);
 
 // NSAttributedString
 void encode(ArgumentEncoder&, NSAttributedString *);
-bool decode(ArgumentDecoder*, RetainPtr<NSAttributedString>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSAttributedString>&);
 
 #if USE(APPKIT)
 // NSColor
 void encode(ArgumentEncoder&, NSColor *);
-bool decode(ArgumentDecoder*, RetainPtr<NSColor>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSColor>&);
 #endif
 
 // NSDictionary
 void encode(ArgumentEncoder&, NSDictionary *);
-bool decode(ArgumentDecoder*, RetainPtr<NSDictionary>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSDictionary>&);
 
 // NSArray
 void encode(ArgumentEncoder&, NSArray *);
-bool decode(ArgumentDecoder*, RetainPtr<NSArray>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSArray>&);
 
 #if USE(APPKIT)
 // NSFont
 void encode(ArgumentEncoder&, NSFont *);
-bool decode(ArgumentDecoder*, RetainPtr<NSFont>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSFont>&);
 #endif
 
 // NSNumber
 void encode(ArgumentEncoder&, NSNumber *);
-bool decode(ArgumentDecoder*, RetainPtr<NSNumber>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSNumber>&);
 
 // NSString
 void encode(ArgumentEncoder&, NSString *);
-bool decode(ArgumentDecoder*, RetainPtr<NSString>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSString>&);
 
 // NSDate
 void encode(ArgumentEncoder&, NSDate *);
-bool decode(ArgumentDecoder*, RetainPtr<NSDate>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSDate>&);
 
 // NSData
 void encode(ArgumentEncoder&, NSData *);
-bool decode(ArgumentDecoder*, RetainPtr<NSData>&);
+bool decode(ArgumentDecoder&, RetainPtr<NSData>&);
 
 } // namespace CoreIPC
 
index b04e4f3..763f10d 100644 (file)
@@ -129,10 +129,10 @@ void encode(ArgumentEncoder& encoder, id object)
     ASSERT_NOT_REACHED();
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<id>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<id>& result)
 {
     NSType type;
-    if (!decoder->decodeEnum(type))
+    if (!decoder.decodeEnum(type))
         return false;
 
     switch (type) {
@@ -244,7 +244,7 @@ void encode(ArgumentEncoder& encoder, NSAttributedString *string)
     }
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSAttributedString>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSAttributedString>& result)
 {
     RetainPtr<NSString> plainString;
     if (!CoreIPC::decode(decoder, plainString))
@@ -255,16 +255,16 @@ bool decode(ArgumentDecoder* decoder, RetainPtr<NSAttributedString>& result)
     RetainPtr<NSMutableAttributedString> resultString(AdoptNS, [[NSMutableAttributedString alloc] initWithString:plainString.get()]);
 
     uint64_t rangeCount;
-    if (!decoder->decode(rangeCount))
+    if (!decoder.decode(rangeCount))
         return false;
 
     while (rangeCount--) {
         uint64_t rangeLocation;
         uint64_t rangeLength;
         RetainPtr<NSDictionary> attributes;
-        if (!decoder->decode(rangeLocation))
+        if (!decoder.decode(rangeLocation))
             return false;
-        if (!decoder->decode(rangeLength))
+        if (!decoder.decode(rangeLength))
             return false;
 
         ASSERT(rangeLocation + rangeLength > rangeLocation);
@@ -287,10 +287,10 @@ void encode(ArgumentEncoder& encoder, NSColor *color)
     encoder << colorFromNSColor(color);
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSColor>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSColor>& result)
 {
     Color color;
-    if (!decoder->decode(color))
+    if (!decoder.decode(color))
         return false;
 
     result = nsColor(color);
@@ -324,10 +324,10 @@ void encode(ArgumentEncoder& encoder, NSDictionary *dictionary)
     }
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSDictionary>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSDictionary>& result)
 {
     uint64_t size;
-    if (!decoder->decode(size))
+    if (!decoder.decode(size))
         return false;
 
     RetainPtr<NSMutableDictionary> dictionary(AdoptNS, [[NSMutableDictionary alloc] initWithCapacity:size]);
@@ -355,7 +355,7 @@ void encode(ArgumentEncoder& encoder, NSFont *font)
     encode(encoder, [[font fontDescriptor] fontAttributes]);
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSFont>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSFont>& result)
 {
     RetainPtr<NSDictionary> fontAttributes;
     if (!decode(decoder, fontAttributes))
@@ -373,7 +373,7 @@ void encode(ArgumentEncoder& encoder, NSNumber *number)
     encode(encoder, (CFNumberRef)number);
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSNumber>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSNumber>& result)
 {
     RetainPtr<CFNumberRef> number;
     if (!decode(decoder, number))
@@ -388,7 +388,7 @@ void encode(ArgumentEncoder& encoder, NSString *string)
     encode(encoder, (CFStringRef)string);
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSString>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSString>& result)
 {
     RetainPtr<CFStringRef> string;
     if (!decode(decoder, string))
@@ -414,10 +414,10 @@ void encode(ArgumentEncoder& encoder, NSArray *array)
     }
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSArray>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSArray>& result)
 {
     uint64_t size;
-    if (!decoder->decode(size))
+    if (!decoder.decode(size))
         return false;
 
     RetainPtr<NSMutableArray> array = adoptNS([[NSMutableArray alloc] initWithCapacity:size]);
@@ -438,7 +438,7 @@ void encode(ArgumentEncoder& encoder, NSDate *date)
     encode(encoder, (CFDateRef)date);
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSDate>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSDate>& result)
 {
     RetainPtr<CFDateRef> date;
     if (!decode(decoder, date))
@@ -453,7 +453,7 @@ void encode(ArgumentEncoder& encoder, NSData *data)
     encode(encoder, (CFDataRef)data);
 }
 
-bool decode(ArgumentDecoder* decoder, RetainPtr<NSData>& result)
+bool decode(ArgumentDecoder& decoder, RetainPtr<NSData>& result)
 {
     RetainPtr<CFDataRef> data;
     if (!decode(decoder, data))
index 6d3507f..0515f20 100644 (file)
@@ -39,7 +39,7 @@ namespace WebKit {
 
 struct AttributedString {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, AttributedString&);
+    static bool decode(CoreIPC::ArgumentDecoder&, AttributedString&);
     
     RetainPtr<NSAttributedString> string;
 };
index 34c17ad..414f808 100644 (file)
@@ -40,10 +40,10 @@ void AttributedString::encode(CoreIPC::ArgumentEncoder& encoder) const
     CoreIPC::encode(encoder, string.get());
 }
 
-bool AttributedString::decode(CoreIPC::ArgumentDecoder* decoder, AttributedString& attributedString)
+bool AttributedString::decode(CoreIPC::ArgumentDecoder& decoder, AttributedString& attributedString)
 {
     bool isNull;
-    if (!decoder->decode(isNull))
+    if (!decoder.decode(isNull))
         return false;
     if (isNull)
         return true;
index afe5b77..d3637b3 100644 (file)
@@ -37,7 +37,7 @@ namespace WebKit {
 
 struct ColorSpaceData {
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, ColorSpaceData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, ColorSpaceData&);
 
     RetainPtr<CGColorSpaceRef> cgColorSpace;
 };
index 0cecb47..0fd8d26 100644 (file)
@@ -60,10 +60,10 @@ void ColorSpaceData::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder.encodeEnum(Null);
 }
 
-bool ColorSpaceData::decode(CoreIPC::ArgumentDecoder* decoder, ColorSpaceData& colorSpaceData)
+bool ColorSpaceData::decode(CoreIPC::ArgumentDecoder& decoder, ColorSpaceData& colorSpaceData)
 {
     EncodedDataType dataType;
-    if (!decoder->decodeEnum(dataType))
+    if (!decoder.decodeEnum(dataType))
         return false;
 
     switch (dataType) {
index 531d245..3546c3b 100644 (file)
@@ -45,9 +45,9 @@ void LayerTreeContext::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << contextID;
 }
 
-bool LayerTreeContext::decode(CoreIPC::ArgumentDecoder* decoder, LayerTreeContext& result)
+bool LayerTreeContext::decode(CoreIPC::ArgumentDecoder& decoder, LayerTreeContext& result)
 {
-    if (!decoder->decode(result.contextID))
+    if (!decoder.decode(result.contextID))
         return false;
 
     return true;
index e371e4c..4191e57 100644 (file)
@@ -48,7 +48,7 @@ private:
 class WebContextObjCObjectGraphDecoder {
 public:
     explicit WebContextObjCObjectGraphDecoder(RefPtr<ObjCObjectGraph>&, WebProcessProxy*);
-    static bool decode(CoreIPC::ArgumentDecoder*, WebContextObjCObjectGraphDecoder&);
+    static bool decode(CoreIPC::ArgumentDecoder&, WebContextObjCObjectGraphDecoder&);
 
 private:
     RefPtr<ObjCObjectGraph>& m_objectGraph;
@@ -68,7 +68,7 @@ private:
 class InjectedBundleObjCObjectGraphDecoder {
 public:
     explicit InjectedBundleObjCObjectGraphDecoder(RefPtr<ObjCObjectGraph>&, WebProcess*);
-    static bool decode(CoreIPC::ArgumentDecoder*, InjectedBundleObjCObjectGraphDecoder&);
+    static bool decode(CoreIPC::ArgumentDecoder&, InjectedBundleObjCObjectGraphDecoder&);
 
 private:
     RefPtr<ObjCObjectGraph>& m_objectGraph;
index 63e18b7..bd25790 100644 (file)
@@ -160,10 +160,10 @@ protected:
 template<typename Owner>
 class ObjCObjectGraphDecoder {
 public:
-    static bool baseDecode(CoreIPC::ArgumentDecoder* decoder, Owner& coder, WebKitNSType& type)
+    static bool baseDecode(CoreIPC::ArgumentDecoder& decoder, Owner& coder, WebKitNSType& type)
     {
         uint32_t typeAsUInt32;
-        if (!decoder->decode(typeAsUInt32))
+        if (!decoder.decode(typeAsUInt32))
             return false;
 
         type = static_cast<WebKitNSType>(typeAsUInt32);
@@ -178,14 +178,14 @@ public:
         }
         case NSArrayType: {
             uint64_t size;
-            if (!decoder->decode(size))
+            if (!decoder.decode(size))
                 return false;
 
             RetainPtr<NSMutableArray> array = adoptNS([[NSMutableArray alloc] initWithCapacity:size]);
             for (uint64_t i = 0; i < size; ++i) {
                 RetainPtr<id> value;
                 Owner messageCoder(coder, value);
-                if (!decoder->decode(messageCoder))
+                if (!decoder.decode(messageCoder))
                     return false;
 
                 [array.get() addObject:value.get()];
@@ -196,7 +196,7 @@ public:
         }
         case NSDictionaryType: {
             uint64_t size;
-            if (!decoder->decode(size))
+            if (!decoder.decode(size))
                 return false;
 
             RetainPtr<NSMutableDictionary> dictionary = adoptNS([[NSMutableDictionary alloc] initWithCapacity:size]);
@@ -204,12 +204,12 @@ public:
                 // Try to decode the key name.
                 RetainPtr<id> key;
                 Owner keyMessageCoder(coder, key);
-                if (!decoder->decode(keyMessageCoder))
+                if (!decoder.decode(keyMessageCoder))
                     return false;
 
                 RetainPtr<id> value;
                 Owner valueMessageCoder(coder, value);
-                if (!decoder->decode(valueMessageCoder))
+                if (!decoder.decode(valueMessageCoder))
                     return false;
 
                 [dictionary.get() setObject:value.get() forKey:key.get()];
@@ -306,7 +306,7 @@ public:
     {
     }
 
-    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebContextObjCObjectGraphDecoderImpl& coder)
+    static bool decode(CoreIPC::ArgumentDecoder& decoder, WebContextObjCObjectGraphDecoderImpl& coder)
     {
         WebKitNSType type = NullType;
         if (!Base::baseDecode(decoder, coder, type))
@@ -324,7 +324,7 @@ public:
 #if defined(__LP64__) && defined(__clang__)
         case WKBrowsingContextControllerType: {
             uint64_t pageID;
-            if (!decoder->decode(pageID))
+            if (!decoder.decode(pageID))
                 return false;
 
             WebPageProxy* webPage = coder.m_process->webPage(pageID);
@@ -397,7 +397,7 @@ public:
     {
     }
 
-    static bool decode(CoreIPC::ArgumentDecoder* decoder, InjectedBundleObjCObjectGraphDecoderImpl& coder)
+    static bool decode(CoreIPC::ArgumentDecoder& decoder, InjectedBundleObjCObjectGraphDecoderImpl& coder)
     {
         WebKitNSType type = NullType;
         if (!Base::baseDecode(decoder, coder, type))
@@ -415,7 +415,7 @@ public:
 #if defined(__LP64__) && defined(__clang__)
         case WKBrowsingContextControllerType: {
             uint64_t pageID;
-            if (!decoder->decode(pageID))
+            if (!decoder.decode(pageID))
                 return false;
 
             WebPage* webPage = coder.m_process->webPage(pageID);
@@ -456,11 +456,11 @@ WebContextObjCObjectGraphDecoder::WebContextObjCObjectGraphDecoder(RefPtr<ObjCOb
 {
 }
 
-bool WebContextObjCObjectGraphDecoder::decode(CoreIPC::ArgumentDecoder* decoder, WebContextObjCObjectGraphDecoder& coder)
+bool WebContextObjCObjectGraphDecoder::decode(CoreIPC::ArgumentDecoder& decoder, WebContextObjCObjectGraphDecoder& coder)
 {
     RetainPtr<id> root;
     WebContextObjCObjectGraphDecoderImpl coderImpl(root, coder.m_process);
-    if (!decoder->decode(coderImpl))
+    if (!decoder.decode(coderImpl))
         return false;
 
     coder.m_objectGraph = ObjCObjectGraph::create(root.get());
@@ -483,11 +483,11 @@ InjectedBundleObjCObjectGraphDecoder::InjectedBundleObjCObjectGraphDecoder(RefPt
 {
 }
 
-bool InjectedBundleObjCObjectGraphDecoder::decode(CoreIPC::ArgumentDecoder* decoder, InjectedBundleObjCObjectGraphDecoder& coder)
+bool InjectedBundleObjCObjectGraphDecoder::decode(CoreIPC::ArgumentDecoder& decoder, InjectedBundleObjCObjectGraphDecoder& coder)
 {
     RetainPtr<id> root;
     InjectedBundleObjCObjectGraphDecoderImpl coderImpl(root, coder.m_process);
-    if (!decoder->decode(coderImpl))
+    if (!decoder.decode(coderImpl))
         return false;
 
     coder.m_objectGraph = ObjCObjectGraph::create(root.get());
index 93f09f3..9ea1a2f 100644 (file)
@@ -45,7 +45,7 @@ public:
     CFArrayRef certificateChain() const { return m_certificateChain.get(); }
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder* decoder, PlatformCertificateInfo& t);
+    static bool decode(CoreIPC::ArgumentDecoder&, PlatformCertificateInfo&);
 
 #ifndef NDEBUG
     void dump() const;
index 6eb1b16..62ae8a9 100644 (file)
@@ -59,10 +59,10 @@ void PlatformCertificateInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
     CoreIPC::encode(encoder, m_certificateChain.get());
 }
 
-bool PlatformCertificateInfo::decode(CoreIPC::ArgumentDecoder* decoder, PlatformCertificateInfo& c)
+bool PlatformCertificateInfo::decode(CoreIPC::ArgumentDecoder& decoder, PlatformCertificateInfo& c)
 {
     bool hasCertificateChain;
-    if (!decoder->decode(hasCertificateChain))
+    if (!decoder.decode(hasCertificateChain))
         return false;
 
     if (!hasCertificateChain)
index d9dd6a2..ea50034 100644 (file)
@@ -54,7 +54,7 @@ public:
         LayerProperties();
 
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, LayerProperties&);
+        static bool decode(CoreIPC::ArgumentDecoder&, LayerProperties&);
 
         unsigned changedProperties;
 
@@ -68,7 +68,7 @@ public:
     ~RemoteLayerTreeTransaction();
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, RemoteLayerTreeTransaction&);
+    static bool decode(CoreIPC::ArgumentDecoder&, RemoteLayerTreeTransaction&);
 
     uint64_t rootLayerID() const { return m_rootLayerID; }
     void setRootLayerID(uint64_t rootLayerID);
index b00addf..e710e2d 100644 (file)
@@ -60,18 +60,18 @@ void RemoteLayerTreeTransaction::LayerProperties::encode(CoreIPC::ArgumentEncode
         encoder << size;
 }
 
-bool RemoteLayerTreeTransaction::LayerProperties::decode(CoreIPC::ArgumentDecoder* decoder, LayerProperties& result)
+bool RemoteLayerTreeTransaction::LayerProperties::decode(CoreIPC::ArgumentDecoder& decoder, LayerProperties& result)
 {
-    if (!decoder->decode(result.changedProperties))
+    if (!decoder.decode(result.changedProperties))
         return false;
 
     if (result.changedProperties & NameChanged) {
-        if (!decoder->decode(result.name))
+        if (!decoder.decode(result.name))
             return false;
     }
 
     if (result.changedProperties & ChildrenChanged) {
-        if (!decoder->decode(result.children))
+        if (!decoder.decode(result.children))
             return false;
 
         for (auto layerID: result.children) {
@@ -81,12 +81,12 @@ bool RemoteLayerTreeTransaction::LayerProperties::decode(CoreIPC::ArgumentDecode
     }
 
     if (result.changedProperties & PositionChanged) {
-        if (!decoder->decode(result.position))
+        if (!decoder.decode(result.position))
             return false;
     }
 
     if (result.changedProperties & SizeChanged) {
-        if (!decoder->decode(result.size))
+        if (!decoder.decode(result.size))
             return false;
     }
     return true;
@@ -107,17 +107,17 @@ void RemoteLayerTreeTransaction::encode(CoreIPC::ArgumentEncoder& encoder) const
     encoder << m_destroyedLayerIDs;
 }
 
-bool RemoteLayerTreeTransaction::decode(CoreIPC::ArgumentDecoder* decoder, RemoteLayerTreeTransaction& result)
+bool RemoteLayerTreeTransaction::decode(CoreIPC::ArgumentDecoder& decoder, RemoteLayerTreeTransaction& result)
 {
-    if (!decoder->decode(result.m_rootLayerID))
+    if (!decoder.decode(result.m_rootLayerID))
         return false;
     if (!result.m_rootLayerID)
         return false;
 
-    if (!decoder->decode(result.m_changedLayerProperties))
+    if (!decoder.decode(result.m_changedLayerProperties))
         return false;
 
-    if (!decoder->decode(result.m_destroyedLayerIDs))
+    if (!decoder.decode(result.m_destroyedLayerIDs))
         return false;
     for (uint64_t layerID: result.m_destroyedLayerIDs) {
         if (!layerID)
index bb30468..8f3a620 100644 (file)
@@ -71,12 +71,12 @@ void SandboxExtension::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
     m_sandboxExtension = 0;
 }
 
-bool SandboxExtension::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& result)
+bool SandboxExtension::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& result)
 {
     ASSERT(!result.m_sandboxExtension);
 
     CoreIPC::DataReference dataReference;
-    if (!decoder->decode(dataReference))
+    if (!decoder.decode(dataReference))
         return false;
 
     if (dataReference.isEmpty())
@@ -134,14 +134,14 @@ void SandboxExtension::HandleArray::encode(CoreIPC::ArgumentEncoder& encoder) co
     
 }
 
-bool SandboxExtension::HandleArray::decode(CoreIPC::ArgumentDecoder* decoder, SandboxExtension::HandleArray& handles)
+bool SandboxExtension::HandleArray::decode(CoreIPC::ArgumentDecoder& decoder, SandboxExtension::HandleArray& handles)
 {
     uint64_t size;
-    if (!decoder->decode(size))
+    if (!decoder.decode(size))
         return false;
     handles.allocate(size);
     for (size_t i = 0; i < size; i++) {
-        if (!decoder->decode(handles[i]))
+        if (!decoder.decode(handles[i]))
             return false;
     }
     return true;
index be9f2a0..4290519 100644 (file)
@@ -60,16 +60,16 @@ void SecItemRequestData::encode(CoreIPC::ArgumentEncoder& encoder) const
         CoreIPC::encode(encoder, m_attributesToMatch.get());
 }
 
-bool SecItemRequestData::decode(CoreIPC::ArgumentDecoder* decoder, SecItemRequestData& secItemRequestData)
+bool SecItemRequestData::decode(CoreIPC::ArgumentDecoder& decoder, SecItemRequestData& secItemRequestData)
 {    
-    if (!decoder->decodeEnum(secItemRequestData.m_type))
+    if (!decoder.decodeEnum(secItemRequestData.m_type))
         return false;
 
     if (!CoreIPC::decode(decoder, secItemRequestData.m_queryDictionary))
         return false;
     
     bool expectAttributes;
-    if (!decoder->decode(expectAttributes))
+    if (!decoder.decode(expectAttributes))
         return false;
     
     if (expectAttributes && !CoreIPC::decode(decoder, secItemRequestData.m_attributesToMatch))
index 442d56d..5909af8 100644 (file)
@@ -50,7 +50,7 @@ public:
     SecItemRequestData(Type, CFDictionaryRef query, CFDictionaryRef attributesToMatch);
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, SecItemRequestData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, SecItemRequestData&);
 
     Type type() const { return m_type; }
 
index 93dbe2b..0dcf609 100644 (file)
@@ -49,16 +49,16 @@ void SecItemResponseData::encode(CoreIPC::ArgumentEncoder& encoder) const
         CoreIPC::encode(encoder, m_resultObject.get());
 }
 
-bool SecItemResponseData::decode(CoreIPC::ArgumentDecoder* decoder, SecItemResponseData& secItemResponseData)
+bool SecItemResponseData::decode(CoreIPC::ArgumentDecoder& decoder, SecItemResponseData& secItemResponseData)
 {
     int64_t resultCode;
-    if (!decoder->decode(resultCode))
+    if (!decoder.decode(resultCode))
         return false;
     secItemResponseData.m_resultCode = (OSStatus)resultCode;
     secItemResponseData.m_resultObject = 0;
 
     bool expectResultObject;
-    if (!decoder->decode(expectResultObject))
+    if (!decoder.decode(expectResultObject))
         return false;
 
     if (expectResultObject && !CoreIPC::decode(decoder, secItemResponseData.m_resultObject))
index cf5c9ee..9de461f 100644 (file)
@@ -41,7 +41,7 @@ public:
     SecItemResponseData(OSStatus, CFTypeRef result);
 
     void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder*, SecItemResponseData&);
+    static bool decode(CoreIPC::ArgumentDecoder&, SecItemResponseData&);
 
     RetainPtr<CFTypeRef>& resultObject() { return m_resultObject; }
     OSStatus resultCode() const { return m_resultCode; }
index cc26dce..a2e5232 100644 (file)
@@ -50,10 +50,10 @@ void ArgumentCoder<ResourceRequest>::encodePlatformData(ArgumentEncoder& encoder
     CoreIPC::encode(encoder, dictionary.get());
 }
 
-bool ArgumentCoder<ResourceRequest>::decodePlatformData(ArgumentDecoder* decoder, ResourceRequest& resourceRequest)
+bool ArgumentCoder<ResourceRequest>::decodePlatformData(ArgumentDecoder& decoder, ResourceRequest& resourceRequest)
 {
     bool requestIsPresent;
-    if (!decoder->decode(requestIsPresent))
+    if (!decoder.decode(requestIsPresent))
         return false;
 
     if (!requestIsPresent) {
@@ -85,10 +85,10 @@ void ArgumentCoder<ResourceResponse>::encodePlatformData(ArgumentEncoder& encode
     CoreIPC::encode(encoder, dictionary.get());
 }
 
-bool ArgumentCoder<ResourceResponse>::decodePlatformData(ArgumentDecoder* decoder, ResourceResponse& resourceResponse)
+bool ArgumentCoder<ResourceResponse>::decodePlatformData(ArgumentDecoder& decoder, ResourceResponse& resourceResponse)
 {
     bool responseIsPresent;
-    if (!decoder->decode(responseIsPresent))
+    if (!decoder.decode(responseIsPresent))
         return false;
 
     if (!responseIsPresent) {
@@ -147,10 +147,10 @@ void ArgumentCoder<ResourceError>::encodePlatformData(ArgumentEncoder& encoder,
     encoder << PlatformCertificateInfo((CFArrayRef)peerCertificateChain);
 }
 
-bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder* decoder, ResourceError& resourceError)
+bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder& decoder, ResourceError& resourceError)
 {
     bool errorIsNull;
-    if (!decoder->decode(errorIsNull))
+    if (!decoder.decode(errorIsNull))
         return false;
     
     if (errorIsNull) {
@@ -159,19 +159,19 @@ bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder* decoder,
     }
 
     String domain;
-    if (!decoder->decode(domain))
+    if (!decoder.decode(domain))
         return false;
 
     int64_t code;
-    if (!decoder->decode(code))
+    if (!decoder.decode(code))
         return false;
 
     HashMap<String, String> stringUserInfoMap;
-    if (!decoder->decode(stringUserInfoMap))
+    if (!decoder.decode(stringUserInfoMap))
         return false;
 
     PlatformCertificateInfo certificate;
-    if (!decoder->decode(certificate))
+    if (!decoder.decode(certificate))
         return false;
 
     NSUInteger userInfoSize = stringUserInfoMap.size();
@@ -199,12 +199,12 @@ void ArgumentCoder<KeypressCommand>::encode(ArgumentEncoder& encoder, const Keyp
     encoder << keypressCommand.commandName << keypressCommand.text;
 }
     
-bool ArgumentCoder<KeypressCommand>::decode(ArgumentDecoder* decoder, KeypressCommand& keypressCommand)
+bool ArgumentCoder<KeypressCommand>::decode(ArgumentDecoder& decoder, KeypressCommand& keypressCommand)
 {
-    if (!decoder->decode(keypressCommand.commandName))
+    if (!decoder.decode(keypressCommand.commandName))
         return false;
 
-    if (!decoder->decode(keypressCommand.text))
+    if (!decoder.decode(keypressCommand.text))
         return false;
 
     return true;
index 29be36f..041c234 100644 (file)
@@ -107,7 +107,7 @@ public:
     {
     }
 
-    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebContextUserMessageDecoder& coder)
+    static bool decode(CoreIPC::ArgumentDecoder& decoder, WebContextUserMessageDecoder& coder)
     {
         APIObject::Type type = APIObject::TypeNull;
         if (!Base::baseDecode(decoder, coder, type))
@@ -119,21 +119,21 @@ public:
         switch (type) {
         case APIObject::TypeBundlePage: {
             uint64_t pageID;
-            if (!decoder->decode(pageID))
+            if (!decoder.decode(pageID))
                 return false;
             coder.m_root = coder.m_process->webPage(pageID);
             break;
         }
         case APIObject::TypeBundleFrame: {
             uint64_t frameID;
-            if (!decoder->decode(frameID))
+            if (!decoder.decode(frameID))
                 return false;
             coder.m_root = coder.m_process->webFrame(frameID);
             break;
         }
         case APIObject::TypeBundlePageGroup: {
             uint64_t pageGroupID;
-            if (!decoder->decode(pageGroupID))
+            if (!decoder.decode(pageGroupID))
                 return false;
             coder.m_root = WebPageGroup::get(pageGroupID);
             break;
@@ -142,7 +142,7 @@ public:
         case APIObject::TypeObjCObjectGraph: {
             RefPtr<ObjCObjectGraph> objectGraph;
             WebContextObjCObjectGraphDecoder objectGraphDecoder(objectGraph, coder.m_process);
-            if (!decoder->decode(objectGraphDecoder))
+            if (!decoder.decode(objectGraphDecoder))
                 return false;
             coder.m_root = objectGraph.get();
             break;
index aa783a3..70af5e5 100644 (file)
@@ -108,7 +108,7 @@ public:
     {
     }
 
-    static bool decode(CoreIPC::ArgumentDecoder* decoder, InjectedBundleUserMessageDecoder& coder)
+    static bool decode(CoreIPC::ArgumentDecoder& decoder, InjectedBundleUserMessageDecoder& coder)
     {
         APIObject::Type type = APIObject::TypeNull;
         if (!Base::baseDecode(decoder, coder, type))
@@ -120,21 +120,21 @@ public:
         switch (type) {
         case APIObject::TypePage: {
             uint64_t pageID;
-            if (!decoder->decode(pageID))
+            if (!decoder.decode(pageID))
                 return false;
             coder.m_root = WebProcess::shared().webPage(pageID);
             break;
         }
         case APIObject::TypeFrame: {
             uint64_t frameID;
-            if (!decoder->decode(frameID))
+            if (!decoder.decode(frameID))
                 return false;
             coder.m_root = WebProcess::shared().webFrame(frameID);
             break;
         }
         case APIObject::TypePageGroup: {
             WebPageGroupData pageGroupData;
-            if (!decoder->decode(pageGroupData))
+            if (!decoder.decode(pageGroupData))
                 return false;
             coder.m_root = WebProcess::shared().webPageGroup(pageGroupData);
             break;
@@ -143,7 +143,7 @@ public:
         case APIObject::TypeObjCObjectGraph: {
             RefPtr<ObjCObjectGraph> objectGraph;
             InjectedBundleObjCObjectGraphDecoder objectGraphDecoder(objectGraph, &WebProcess::shared());
-            if (!decoder->decode(objectGraphDecoder))
+            if (!decoder.decode(objectGraphDecoder))
                 return false;
             coder.m_root = objectGraph.get();
             break;
index f2c6af4..90e5e76 100644 (file)
@@ -46,30 +46,30 @@ void Plugin::Parameters::encode(CoreIPC::ArgumentEncoder& encoder) const
 #endif
 }
 
-bool Plugin::Parameters::decode(CoreIPC::ArgumentDecoder* decoder, Parameters& parameters)
+bool Plugin::Parameters::decode(CoreIPC::ArgumentDecoder& decoder, Parameters& parameters)
 {
     String urlString;
-    if (!decoder->decode(urlString))
+    if (!decoder.decode(urlString))
         return false;
     // FIXME: We can't assume that the url passed in here is valid.
     parameters.url = KURL(ParsedURLString, urlString);
 
-    if (!decoder->decode(parameters.names))
+    if (!decoder.decode(parameters.names))
         return false;
-    if (!decoder->decode(parameters.values))
+    if (!decoder.decode(parameters.values))
         return false;
-    if (!decoder->decode(parameters.mimeType))
+    if (!decoder.decode(parameters.mimeType))
         return false;
-    if (!decoder->decode(parameters.isFullFramePlugin))
+    if (!decoder.decode(parameters.isFullFramePlugin))
         return false;
-    if (!decoder->decode(parameters.shouldUseManualLoader))
+    if (!decoder.decode(parameters.shouldUseManualLoader))
         return false;
 #if PLATFORM(MAC)
-    if (!decoder->decodeEnum(parameters.layerHostingMode))
+    if (!decoder.decodeEnum(parameters.layerHostingMode))
         return false;
 #endif
     if (parameters.names.size() != parameters.values.size()) {
-        decoder->markInvalid();
+        decoder.markInvalid();
         return false;
     }
 
index 23a9eb5..a5b960f 100644 (file)
@@ -80,7 +80,7 @@ public:
 #endif
 
         void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder*, Parameters&);
+        static bool decode(CoreIPC::ArgumentDecoder&, Parameters&);
     };
 
     // Sets the active plug-in controller and initializes the plug-in.