Move code over to the IPC namespace.

author andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Mon, 30 Dec 2013 20:20:02 +0000 (20:20 +0000)

committer andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Mon, 30 Dec 2013 20:20:02 +0000 (20:20 +0000)
author andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 30 Dec 2013 20:20:02 +0000 (20:20 +0000)
committer andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 30 Dec 2013 20:20:02 +0000 (20:20 +0000)
diff --git a/Source/WebKit2/ChangeLog b/Source/WebKit2/ChangeLog

index 7a6ff23..ef3e9c1 100644 (file)
--- a/Source/WebKit2/ChangeLog
+++ b/Source/WebKit2/ChangeLog
@@ -1,5 +1,774 @@
  2013-12-30  Anders Carlsson  <andersca@apple.com>
  
+        Move code over to the IPC namespace.
+
+        Rubber-stamped by Andreas Kling.
+
+        * DatabaseProcess/DatabaseProcess.cpp:
+        (WebKit::DatabaseProcess::initializeConnection):
+        (WebKit::DatabaseProcess::didClose):
+        (WebKit::DatabaseProcess::didReceiveInvalidMessage):
+        (WebKit::DatabaseProcess::createDatabaseToWebProcessConnection):
+        * DatabaseProcess/DatabaseProcess.h:
+        * DatabaseProcess/DatabaseToWebProcessConnection.cpp:
+        (WebKit::DatabaseToWebProcessConnection::create):
+        (WebKit::DatabaseToWebProcessConnection::DatabaseToWebProcessConnection):
+        (WebKit::DatabaseToWebProcessConnection::didReceiveMessage):
+        (WebKit::DatabaseToWebProcessConnection::didClose):
+        (WebKit::DatabaseToWebProcessConnection::didReceiveInvalidMessage):
+        * DatabaseProcess/DatabaseToWebProcessConnection.h:
+        (WebKit::DatabaseToWebProcessConnection::connection):
+        * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp:
+        (WebKit::DatabaseProcessIDBConnection::messageSenderConnection):
+        * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h:
+        * NetworkProcess/AsynchronousNetworkLoaderClient.cpp:
+        (WebKit::AsynchronousNetworkLoaderClient::willSendRequest):
+        (WebKit::AsynchronousNetworkLoaderClient::canAuthenticateAgainstProtectionSpace):
+        (WebKit::AsynchronousNetworkLoaderClient::didReceiveBuffer):
+        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
+        (WebKit::NetworkConnectionToWebProcess::create):
+        (WebKit::NetworkConnectionToWebProcess::NetworkConnectionToWebProcess):
+        (WebKit::NetworkConnectionToWebProcess::didReceiveMessage):
+        (WebKit::NetworkConnectionToWebProcess::didReceiveSyncMessage):
+        (WebKit::NetworkConnectionToWebProcess::didClose):
+        (WebKit::NetworkConnectionToWebProcess::didReceiveInvalidMessage):
+        * NetworkProcess/NetworkConnectionToWebProcess.h:
+        (WebKit::NetworkConnectionToWebProcess::connection):
+        * NetworkProcess/NetworkProcess.cpp:
+        (WebKit::NetworkProcess::didReceiveMessage):
+        (WebKit::NetworkProcess::didReceiveSyncMessage):
+        (WebKit::NetworkProcess::didClose):
+        (WebKit::NetworkProcess::didReceiveInvalidMessage):
+        (WebKit::NetworkProcess::downloadProxyConnection):
+        (WebKit::NetworkProcess::initializeConnection):
+        (WebKit::NetworkProcess::createNetworkConnectionToWebProcess):
+        * NetworkProcess/NetworkProcess.h:
+        * NetworkProcess/NetworkResourceLoader.cpp:
+        (WebKit::NetworkResourceLoader::messageSenderConnection):
+        * NetworkProcess/NetworkResourceLoader.h:
+        * NetworkProcess/mac/DiskCacheMonitor.h:
+        * NetworkProcess/mac/DiskCacheMonitor.mm:
+        (WebKit::DiskCacheMonitor::messageSenderConnection):
+        * Platform/IPC/ArgumentCoder.h:
+        * Platform/IPC/ArgumentCoders.cpp:
+        * Platform/IPC/ArgumentCoders.h:
+        * Platform/IPC/ArgumentDecoder.cpp:
+        * Platform/IPC/ArgumentDecoder.h:
+        * Platform/IPC/ArgumentEncoder.cpp:
+        * Platform/IPC/ArgumentEncoder.h:
+        * Platform/IPC/Arguments.h:
+        * Platform/IPC/Attachment.cpp:
+        * Platform/IPC/Attachment.h:
+        * Platform/IPC/Connection.cpp:
+        (IPC::Connection::Connection):
+        * Platform/IPC/Connection.h:
+        * Platform/IPC/HandleMessage.h:
+        * Platform/IPC/MessageDecoder.cpp:
+        * Platform/IPC/MessageDecoder.h:
+        * Platform/IPC/MessageEncoder.cpp:
+        * Platform/IPC/MessageEncoder.h:
+        * Platform/IPC/MessageFlags.h:
+        * Platform/IPC/MessageReceiver.h:
+        * Platform/IPC/MessageReceiverMap.cpp:
+        * Platform/IPC/MessageReceiverMap.h:
+        * Platform/IPC/mac/ConnectionMac.cpp:
+        * Platform/IPC/mac/ImportanceAssertion.h:
+        * Platform/IPC/mac/MachPort.h:
+        * Platform/SharedMemory.h:
+        * Platform/mac/SharedMemoryMac.cpp:
+        (WebKit::SharedMemory::Handle::encode):
+        (WebKit::SharedMemory::Handle::decode):
+        * PluginProcess/PluginControllerProxy.cpp:
+        (WebKit::PluginControllerProxy::streamDidReceiveData):
+        (WebKit::PluginControllerProxy::manualStreamDidReceiveData):
+        * PluginProcess/PluginControllerProxy.h:
+        * PluginProcess/PluginControllerProxy.messages.in:
+        * PluginProcess/PluginCreationParameters.cpp:
+        (WebKit::PluginCreationParameters::encode):
+        (WebKit::PluginCreationParameters::decode):
+        * PluginProcess/PluginCreationParameters.h:
+        * PluginProcess/PluginProcess.cpp:
+        (WebKit::PluginProcess::didReceiveMessage):
+        (WebKit::PluginProcess::didClose):
+        (WebKit::PluginProcess::didReceiveInvalidMessage):
+        (WebKit::PluginProcess::createWebProcessConnection):
+        * PluginProcess/PluginProcess.h:
+        * PluginProcess/WebProcessConnection.cpp:
+        (WebKit::WebProcessConnection::create):
+        (WebKit::WebProcessConnection::WebProcessConnection):
+        (WebKit::WebProcessConnection::setGlobalException):
+        (WebKit::WebProcessConnection::didReceiveMessage):
+        (WebKit::WebProcessConnection::didReceiveSyncMessage):
+        (WebKit::WebProcessConnection::didClose):
+        (WebKit::WebProcessConnection::didReceiveInvalidMessage):
+        * PluginProcess/WebProcessConnection.h:
+        (WebKit::WebProcessConnection::connection):
+        * PluginProcess/mac/PluginControllerProxyMac.mm:
+        (WebKit::PluginControllerProxy::setComplexTextInputState):
+        * Scripts/webkit2/messages.py:
+        (arguments_type_old):
+        (message_to_struct_declaration):
+        (forward_declarations_and_headers):
+        (generate_messages_header):
+        (async_message_statement):
+        (sync_message_statement):
+        (headers_for_type):
+        (generate_message_handler):
+        * Scripts/webkit2/messages_unittest.py:
+        (IPC):
+        (std):
+        * Shared/API/Cocoa/RemoteObjectRegistry.h:
+        * Shared/APIGeometry.cpp:
+        (API::Point::encode):
+        (API::Point::decode):
+        (API::Size::encode):
+        (API::Size::decode):
+        (API::Rect::encode):
+        (API::Rect::decode):
+        * Shared/APIGeometry.h:
+        * Shared/APINumber.h:
+        (API::Number::encode):
+        (API::Number::decode):
+        * Shared/Authentication/AuthenticationManager.h:
+        * Shared/ChildProcess.cpp:
+        (WebKit::didCloseOnConnectionWorkQueue):
+        (WebKit::ChildProcess::initialize):
+        (WebKit::ChildProcess::initializeConnection):
+        (WebKit::ChildProcess::addMessageReceiver):
+        (WebKit::ChildProcess::removeMessageReceiver):
+        (WebKit::ChildProcess::messageSenderConnection):
+        * Shared/ChildProcess.h:
+        (WebKit::ChildProcess::parentProcessConnection):
+        (WebKit::ChildProcess::messageReceiverMap):
+        * Shared/ChildProcessProxy.cpp:
+        (WebKit::ChildProcessProxy::fromConnection):
+        (WebKit::ChildProcessProxy::sendMessage):
+        (WebKit::ChildProcessProxy::addMessageReceiver):
+        (WebKit::ChildProcessProxy::removeMessageReceiver):
+        (WebKit::ChildProcessProxy::dispatchMessage):
+        (WebKit::ChildProcessProxy::dispatchSyncMessage):
+        (WebKit::ChildProcessProxy::didFinishLaunching):
+        (WebKit::ChildProcessProxy::connectionWillOpen):
+        (WebKit::ChildProcessProxy::connectionWillClose):
+        * Shared/ChildProcessProxy.h:
+        (WebKit::ChildProcessProxy::connection):
+        (WebKit::ChildProcessProxy::send):
+        * Shared/ChildProcessSupplement.h:
+        (WebKit::ChildProcessSupplement::initializeConnection):
+        * Shared/ConnectionStack.h:
+        (WebKit::ConnectionStack::current):
+        (WebKit::ConnectionStack::CurrentConnectionPusher::CurrentConnectionPusher):
+        * Shared/CoreIPCSupport/WebContextMessageKinds.h:
+        (WebContextLegacyMessages::messageReceiverName):
+        (WebContextLegacyMessages::postMessageMessageName):
+        (WebContextLegacyMessages::postSynchronousMessageMessageName):
+        * Shared/Databases/DatabaseProcessCreationParameters.cpp:
+        (WebKit::DatabaseProcessCreationParameters::encode):
+        (WebKit::DatabaseProcessCreationParameters::decode):
+        * Shared/Databases/DatabaseProcessCreationParameters.h:
+        * Shared/DictionaryPopupInfo.cpp:
+        (WebKit::DictionaryPopupInfo::encode):
+        (WebKit::DictionaryPopupInfo::decode):
+        * Shared/DictionaryPopupInfo.h:
+        * Shared/Downloads/Download.cpp:
+        (WebKit::Download::didFail):
+        (WebKit::Download::didCancel):
+        (WebKit::Download::messageSenderConnection):
+        * Shared/Downloads/Download.h:
+        * Shared/Downloads/DownloadManager.cpp:
+        (WebKit::DownloadManager::downloadProxyConnection):
+        * Shared/Downloads/DownloadManager.h:
+        * Shared/Downloads/mac/DownloadMac.mm:
+        (WebKit::Download::cancel):
+        (-[WKDownloadAsDelegate download:didFailWithError:]):
+        * Shared/EditorState.cpp:
+        (WebKit::EditorState::encode):
+        (WebKit::EditorState::decode):
+        * Shared/EditorState.h:
+        * Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.h:
+        * Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.mm:
+        (WebKit::ChildProcessMainDelegate::getConnectionIdentifier):
+        * Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.h:
+        * Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.mm:
+        (WebKit::XPCServiceInitializerDelegate::getConnectionIdentifier):
+        * Shared/FileAPI/BlobRegistrationData.cpp:
+        (WebKit::BlobRegistrationData::encode):
+        (WebKit::BlobRegistrationData::decode):
+        * Shared/FileAPI/BlobRegistrationData.h:
+        * Shared/FontInfo.cpp:
+        (WebKit::FontInfo::encode):
+        (WebKit::FontInfo::decode):
+        * Shared/FontInfo.h:
+        * Shared/LayerTreeContext.h:
+        * Shared/Network/CustomProtocols/CustomProtocolManager.h:
+        * Shared/Network/CustomProtocols/CustomProtocolManager.messages.in:
+        * Shared/Network/CustomProtocols/mac/CustomProtocolManagerMac.mm:
+        (WebKit::CustomProtocolManager::initializeConnection):
+        (WebKit::CustomProtocolManager::didLoadData):
+        * Shared/Network/NetworkProcessCreationParameters.cpp:
+        (WebKit::NetworkProcessCreationParameters::encode):
+        (WebKit::NetworkProcessCreationParameters::decode):
+        * Shared/Network/NetworkProcessCreationParameters.h:
+        * Shared/Network/NetworkResourceLoadParameters.cpp:
+        (WebKit::NetworkResourceLoadParameters::encode):
+        (WebKit::NetworkResourceLoadParameters::decode):
+        * Shared/Network/NetworkResourceLoadParameters.h:
+        * Shared/OriginAndDatabases.cpp:
+        (WebKit::OriginAndDatabases::encode):
+        (WebKit::OriginAndDatabases::decode):
+        * Shared/OriginAndDatabases.h:
+        * Shared/PlatformPopupMenuData.cpp:
+        (WebKit::PlatformPopupMenuData::encode):
+        (WebKit::PlatformPopupMenuData::decode):
+        * Shared/PlatformPopupMenuData.h:
+        * Shared/Plugins/NPIdentifierData.cpp:
+        (WebKit::NPIdentifierData::encode):
+        (WebKit::NPIdentifierData::decode):
+        * Shared/Plugins/NPIdentifierData.h:
+        * Shared/Plugins/NPObjectMessageReceiver.h:
+        * Shared/Plugins/NPRemoteObjectMap.cpp:
+        (WebKit::NPRemoteObjectMap::create):
+        (WebKit::NPRemoteObjectMap::NPRemoteObjectMap):
+        (WebKit::NPRemoteObjectMap::didReceiveSyncMessage):
+        * Shared/Plugins/NPRemoteObjectMap.h:
+        (WebKit::NPRemoteObjectMap::connection):
+        * Shared/Plugins/NPVariantData.cpp:
+        (WebKit::NPVariantData::encode):
+        (WebKit::NPVariantData::decode):
+        * Shared/Plugins/NPVariantData.h:
+        * Shared/Plugins/PluginProcessCreationParameters.cpp:
+        (WebKit::PluginProcessCreationParameters::encode):
+        (WebKit::PluginProcessCreationParameters::decode):
+        * Shared/Plugins/PluginProcessCreationParameters.h:
+        * Shared/PrintInfo.cpp:
+        (WebKit::PrintInfo::encode):
+        (WebKit::PrintInfo::decode):
+        * Shared/PrintInfo.h:
+        * Shared/SandboxExtension.h:
+        (WebKit::SandboxExtension::Handle::encode):
+        (WebKit::SandboxExtension::Handle::decode):
+        (WebKit::SandboxExtension::HandleArray::encode):
+        (WebKit::SandboxExtension::HandleArray::decode):
+        * Shared/SecurityOriginData.cpp:
+        (WebKit::SecurityOriginData::encode):
+        (WebKit::SecurityOriginData::decode):
+        * Shared/SecurityOriginData.h:
+        * Shared/SessionState.cpp:
+        (WebKit::SessionState::encode):
+        (WebKit::SessionState::decode):
+        * Shared/SessionState.h:
+        * Shared/ShareableBitmap.cpp:
+        (WebKit::ShareableBitmap::Handle::encode):
+        (WebKit::ShareableBitmap::Handle::decode):
+        * Shared/ShareableBitmap.h:
+        * Shared/ShareableResource.cpp:
+        (WebKit::ShareableResource::Handle::encode):
+        (WebKit::ShareableResource::Handle::decode):
+        * Shared/ShareableResource.h:
+        * Shared/StatisticsData.cpp:
+        (WebKit::StatisticsData::encode):
+        (WebKit::StatisticsData::decode):
+        * Shared/StatisticsData.h:
+        * Shared/TextCheckerState.h:
+        * Shared/UpdateInfo.cpp:
+        (WebKit::UpdateInfo::encode):
+        (WebKit::UpdateInfo::decode):
+        * Shared/UpdateInfo.h:
+        * Shared/UserData.cpp:
+        (WebKit::UserData::encode):
+        (WebKit::UserData::decode):
+        * Shared/UserData.h:
+        * Shared/UserMessageCoders.h:
+        (WebKit::UserMessageEncoder::baseEncode):
+        (WebKit::UserMessageDecoder::baseDecode):
+        * Shared/WebBackForwardListItem.cpp:
+        (WebKit::WebBackForwardListItem::encode):
+        (WebKit::WebBackForwardListItem::decode):
+        * Shared/WebBackForwardListItem.h:
+        * Shared/WebConnection.cpp:
+        (WebKit::WebConnection::postMessage):
+        (WebKit::WebConnection::didReceiveMessage):
+        (WebKit::WebConnection::handleMessage):
+        * Shared/WebConnection.h:
+        * Shared/WebContextMenuItemData.cpp:
+        (WebKit::WebContextMenuItemData::encode):
+        (WebKit::WebContextMenuItemData::decode):
+        * Shared/WebContextMenuItemData.h:
+        * Shared/WebCoreArgumentCoders.cpp:
+        * Shared/WebCoreArgumentCoders.h:
+        * Shared/WebEvent.cpp:
+        (WebKit::WebEvent::encode):
+        (WebKit::WebEvent::decode):
+        * Shared/WebEvent.h:
+        * Shared/WebGeolocationPosition.cpp:
+        (WebKit::WebGeolocationPosition::Data::encode):
+        (WebKit::WebGeolocationPosition::Data::decode):
+        * Shared/WebGeolocationPosition.h:
+        * Shared/WebHitTestResult.cpp:
+        (WebKit::WebHitTestResult::Data::encode):
+        (WebKit::WebHitTestResult::Data::decode):
+        * Shared/WebHitTestResult.h:
+        * Shared/WebKeyboardEvent.cpp:
+        (WebKit::WebKeyboardEvent::encode):
+        (WebKit::WebKeyboardEvent::decode):
+        * Shared/WebMouseEvent.cpp:
+        (WebKit::WebMouseEvent::encode):
+        (WebKit::WebMouseEvent::decode):
+        * Shared/WebNavigationDataStore.h:
+        (WebKit::WebNavigationDataStore::encode):
+        (WebKit::WebNavigationDataStore::decode):
+        * Shared/WebPageCreationParameters.cpp:
+        (WebKit::WebPageCreationParameters::encode):
+        (WebKit::WebPageCreationParameters::decode):
+        * Shared/WebPageCreationParameters.h:
+        * Shared/WebPageGroupData.cpp:
+        (WebKit::WebPageGroupData::encode):
+        (WebKit::WebPageGroupData::decode):
+        * Shared/WebPageGroupData.h:
+        * Shared/WebPlatformTouchPoint.cpp:
+        (WebKit::WebPlatformTouchPoint::encode):
+        (WebKit::WebPlatformTouchPoint::decode):
+        * Shared/WebPopupItem.cpp:
+        (WebKit::WebPopupItem::encode):
+        (WebKit::WebPopupItem::decode):
+        * Shared/WebPopupItem.h:
+        * Shared/WebPreferencesStore.cpp:
+        (WebKit::WebPreferencesStore::encode):
+        (WebKit::WebPreferencesStore::decode):
+        * Shared/WebPreferencesStore.h:
+        * Shared/WebProcessCreationParameters.cpp:
+        (WebKit::WebProcessCreationParameters::encode):
+        (WebKit::WebProcessCreationParameters::decode):
+        * Shared/WebProcessCreationParameters.h:
+        * Shared/WebSerializedScriptValue.h:
+        (WebKit::WebSerializedScriptValue::dataReference):
+        * Shared/WebTouchEvent.cpp:
+        (WebKit::WebTouchEvent::encode):
+        (WebKit::WebTouchEvent::decode):
+        * Shared/WebWheelEvent.cpp:
+        (WebKit::WebWheelEvent::encode):
+        (WebKit::WebWheelEvent::decode):
+        * Shared/cf/ArgumentCodersCF.cpp:
+        (IPC::encode):
+        (IPC::decode):
+        * Shared/cf/ArgumentCodersCF.h:
+        * Shared/mac/ArgumentCodersMac.h:
+        * Shared/mac/ArgumentCodersMac.mm:
+        (IPC::encode):
+        (IPC::decode):
+        * Shared/mac/AttributedString.h:
+        * Shared/mac/AttributedString.mm:
+        (WebKit::AttributedString::encode):
+        (WebKit::AttributedString::decode):
+        * Shared/mac/ColorSpaceData.h:
+        * Shared/mac/ColorSpaceData.mm:
+        (WebKit::ColorSpaceData::encode):
+        (WebKit::ColorSpaceData::decode):
+        * Shared/mac/LayerTreeContextMac.mm:
+        (WebKit::LayerTreeContext::encode):
+        (WebKit::LayerTreeContext::decode):
+        * Shared/mac/ObjCObjectGraphCoders.h:
+        * Shared/mac/ObjCObjectGraphCoders.mm:
+        (WebKit::ObjCObjectGraphEncoder::baseEncode):
+        (WebKit::ObjCObjectGraphDecoder::baseDecode):
+        (WebKit::WebContextObjCObjectGraphEncoderImpl::encode):
+        (WebKit::WebContextObjCObjectGraphDecoderImpl::decode):
+        (WebKit::InjectedBundleObjCObjectGraphEncoderImpl::encode):
+        (WebKit::InjectedBundleObjCObjectGraphDecoderImpl::decode):
+        (WebKit::WebContextObjCObjectGraphEncoder::encode):
+        (WebKit::WebContextObjCObjectGraphDecoder::decode):
+        (WebKit::InjectedBundleObjCObjectGraphEncoder::encode):
+        (WebKit::InjectedBundleObjCObjectGraphDecoder::decode):
+        * Shared/mac/RemoteLayerBackingStore.h:
+        * Shared/mac/RemoteLayerBackingStore.mm:
+        (RemoteLayerBackingStore::encode):
+        (RemoteLayerBackingStore::decode):
+        * Shared/mac/RemoteLayerTreeTransaction.h:
+        * Shared/mac/RemoteLayerTreeTransaction.mm:
+        (WebKit::RemoteLayerTreeTransaction::LayerCreationProperties::encode):
+        (WebKit::RemoteLayerTreeTransaction::LayerCreationProperties::decode):
+        (WebKit::RemoteLayerTreeTransaction::LayerProperties::encode):
+        (WebKit::RemoteLayerTreeTransaction::LayerProperties::decode):
+        (WebKit::RemoteLayerTreeTransaction::encode):
+        (WebKit::RemoteLayerTreeTransaction::decode):
+        * Shared/mac/SandboxExtensionMac.mm:
+        (WebKit::SandboxExtension::Handle::encode):
+        (WebKit::SandboxExtension::Handle::decode):
+        (WebKit::SandboxExtension::HandleArray::encode):
+        (WebKit::SandboxExtension::HandleArray::decode):
+        * Shared/mac/SecItemRequestData.cpp:
+        (WebKit::SecItemRequestData::encode):
+        (WebKit::SecItemRequestData::decode):
+        * Shared/mac/SecItemRequestData.h:
+        * Shared/mac/SecItemResponseData.cpp:
+        (WebKit::SecItemResponseData::encode):
+        (WebKit::SecItemResponseData::decode):
+        * Shared/mac/SecItemResponseData.h:
+        * Shared/mac/SecItemShim.cpp:
+        (WebKit::SecItemShim::initializeConnection):
+        * Shared/mac/SecItemShim.h:
+        * Shared/mac/WebCoreArgumentCodersMac.mm:
+        (IPC::ArgumentCoder<ResourceRequest>::encodePlatformData):
+        (IPC::ArgumentCoder<ResourceRequest>::decodePlatformData):
+        (IPC::ArgumentCoder<ResourceResponse>::encodePlatformData):
+        (IPC::ArgumentCoder<ResourceResponse>::decodePlatformData):
+        (IPC::ArgumentCoder<CertificateInfo>::encode):
+        (IPC::ArgumentCoder<CertificateInfo>::decode):
+        (IPC::ArgumentCoder<ResourceError>::encodePlatformData):
+        (IPC::ArgumentCoder<ResourceError>::decodePlatformData):
+        * UIProcess/API/mac/PageClientImpl.h:
+        * UIProcess/API/mac/PageClientImpl.mm:
+        (WebKit::PageClientImpl::accessibilityWebProcessTokenReceived):
+        * UIProcess/API/mac/WKView.mm:
+        (-[WKView _accessibilityRegisterUIProcessTokens]):
+        * UIProcess/API/mac/WKViewInternal.h:
+        * UIProcess/Authentication/AuthenticationChallengeProxy.cpp:
+        (WebKit::AuthenticationChallengeProxy::AuthenticationChallengeProxy):
+        * UIProcess/Authentication/AuthenticationChallengeProxy.h:
+        (WebKit::AuthenticationChallengeProxy::create):
+        * UIProcess/Databases/DatabaseProcessProxy.cpp:
+        (WebKit::DatabaseProcessProxy::connectionWillOpen):
+        (WebKit::DatabaseProcessProxy::connectionWillClose):
+        (WebKit::DatabaseProcessProxy::getDatabaseProcessConnection):
+        (WebKit::DatabaseProcessProxy::didClose):
+        (WebKit::DatabaseProcessProxy::didReceiveInvalidMessage):
+        (WebKit::DatabaseProcessProxy::didCreateDatabaseToWebProcessConnection):
+        (WebKit::DatabaseProcessProxy::didFinishLaunching):
+        * UIProcess/Databases/DatabaseProcessProxy.h:
+        * UIProcess/Databases/DatabaseProcessProxy.messages.in:
+        * UIProcess/Downloads/DownloadProxy.cpp:
+        (WebKit::createData):
+        (WebKit::DownloadProxy::didFail):
+        (WebKit::DownloadProxy::didCancel):
+        * UIProcess/Downloads/DownloadProxy.h:
+        * UIProcess/Downloads/DownloadProxy.messages.in:
+        * UIProcess/DrawingAreaProxy.h:
+        * UIProcess/Launcher/ProcessLauncher.cpp:
+        (WebKit::ProcessLauncher::didFinishLaunchingProcess):
+        * UIProcess/Launcher/ProcessLauncher.h:
+        * UIProcess/Launcher/mac/ProcessLauncherMac.mm:
+        (WebKit::connectToService):
+        (WebKit::tryPreexistingProcess):
+        (WebKit::createProcess):
+        * UIProcess/Network/CustomProtocols/CustomProtocolManagerProxy.h:
+        * UIProcess/Network/CustomProtocols/mac/CustomProtocolManagerProxyMac.mm:
+        (-[WKCustomProtocolLoader connection:didReceiveData:]):
+        * UIProcess/Network/NetworkProcessProxy.cpp:
+        (WebKit::NetworkProcessProxy::connectionWillOpen):
+        (WebKit::NetworkProcessProxy::connectionWillClose):
+        (WebKit::NetworkProcessProxy::getNetworkProcessConnection):
+        (WebKit::NetworkProcessProxy::networkProcessCrashedOrFailedToLaunch):
+        (WebKit::NetworkProcessProxy::didReceiveMessage):
+        (WebKit::NetworkProcessProxy::didReceiveSyncMessage):
+        (WebKit::NetworkProcessProxy::didClose):
+        (WebKit::NetworkProcessProxy::didReceiveInvalidMessage):
+        (WebKit::NetworkProcessProxy::didCreateNetworkConnectionToWebProcess):
+        (WebKit::NetworkProcessProxy::didFinishLaunching):
+        * UIProcess/Network/NetworkProcessProxy.h:
+        * UIProcess/Network/NetworkProcessProxy.messages.in:
+        * UIProcess/Notifications/WebNotification.h:
+        * UIProcess/PageClient.h:
+        * UIProcess/Plugins/PluginProcessManager.h:
+        * UIProcess/Plugins/PluginProcessProxy.cpp:
+        (WebKit::PluginProcessProxy::getPluginProcessConnection):
+        (WebKit::PluginProcessProxy::pluginProcessCrashedOrFailedToLaunch):
+        (WebKit::PluginProcessProxy::didClose):
+        (WebKit::PluginProcessProxy::didReceiveInvalidMessage):
+        (WebKit::PluginProcessProxy::didFinishLaunching):
+        (WebKit::PluginProcessProxy::didCreateWebProcessConnection):
+        * UIProcess/Plugins/PluginProcessProxy.h:
+        * UIProcess/Plugins/PluginProcessProxy.messages.in:
+        * UIProcess/Plugins/mac/PluginProcessProxyMac.mm:
+        (WebKit::PluginProcessProxy::platformInitializePluginProcess):
+        * UIProcess/Storage/StorageManager.cpp:
+        (WebKit::StorageManager::StorageArea::addListener):
+        (WebKit::StorageManager::StorageArea::removeListener):
+        (WebKit::StorageManager::StorageArea::setItem):
+        (WebKit::StorageManager::StorageArea::removeItem):
+        (WebKit::StorageManager::StorageArea::clear):
+        (WebKit::StorageManager::StorageArea::dispatchEvents):
+        (WebKit::StorageManager::SessionStorageNamespace::allowedConnection):
+        (WebKit::StorageManager::SessionStorageNamespace::create):
+        (WebKit::StorageManager::SessionStorageNamespace::SessionStorageNamespace):
+        (WebKit::StorageManager::SessionStorageNamespace::setAllowedConnection):
+        (WebKit::StorageManager::createSessionStorageNamespace):
+        (WebKit::StorageManager::setAllowedSessionStorageNamespaceConnection):
+        (WebKit::StorageManager::processWillCloseConnection):
+        (WebKit::StorageManager::createLocalStorageMap):
+        (WebKit::StorageManager::createSessionStorageMap):
+        (WebKit::StorageManager::destroyStorageMap):
+        (WebKit::StorageManager::getValues):
+        (WebKit::StorageManager::setItem):
+        (WebKit::StorageManager::removeItem):
+        (WebKit::StorageManager::clear):
+        (WebKit::StorageManager::createSessionStorageNamespaceInternal):
+        (WebKit::StorageManager::setAllowedSessionStorageNamespaceConnectionInternal):
+        (WebKit::StorageManager::invalidateConnectionInternal):
+        (WebKit::StorageManager::findStorageArea):
+        * UIProcess/Storage/StorageManager.h:
+        * UIProcess/WebApplicationCacheManagerProxy.h:
+        * UIProcess/WebConnectionToWebProcess.cpp:
+        (WebKit::WebConnectionToWebProcess::encodeMessageBody):
+        (WebKit::WebConnectionToWebProcess::decodeMessageBody):
+        (WebKit::WebConnectionToWebProcess::messageSenderConnection):
+        * UIProcess/WebConnectionToWebProcess.h:
+        * UIProcess/WebContext.cpp:
+        (WebKit::WebContext::networkingProcessConnection):
+        (WebKit::WebContext::didReceiveInvalidMessage):
+        (WebKit::WebContext::createNewWebProcess):
+        (WebKit::WebContext::postMessageToInjectedBundle):
+        (WebKit::WebContext::addMessageReceiver):
+        (WebKit::WebContext::removeMessageReceiver):
+        (WebKit::WebContext::dispatchMessage):
+        (WebKit::WebContext::dispatchSyncMessage):
+        (WebKit::WebContext::didReceiveMessage):
+        (WebKit::WebContext::didReceiveSyncMessage):
+        * UIProcess/WebContext.h:
+        * UIProcess/WebContextUserMessageCoders.h:
+        (WebKit::WebContextUserMessageEncoder::encode):
+        (WebKit::WebContextUserMessageDecoder::decode):
+        * UIProcess/WebCookieManagerProxy.h:
+        * UIProcess/WebDatabaseManagerProxy.h:
+        * UIProcess/WebEditCommandProxy.cpp:
+        (WebKit::WebEditCommandProxy::unapply):
+        (WebKit::WebEditCommandProxy::reapply):
+        * UIProcess/WebFrameProxy.h:
+        * UIProcess/WebFullScreenManagerProxy.h:
+        * UIProcess/WebGeolocationManagerProxy.cpp:
+        (WebKit::WebGeolocationManagerProxy::startUpdating):
+        (WebKit::WebGeolocationManagerProxy::stopUpdating):
+        (WebKit::WebGeolocationManagerProxy::removeRequester):
+        (WebKit::WebGeolocationManagerProxy::setEnableHighAccuracy):
+        * UIProcess/WebGeolocationManagerProxy.h:
+        * UIProcess/WebIconDatabase.cpp:
+        (WebKit::WebIconDatabase::setIconDataForIconURL):
+        (WebKit::WebIconDatabase::synchronousIconDataForPageURL):
+        * UIProcess/WebIconDatabase.h:
+        * UIProcess/WebIconDatabase.messages.in:
+        * UIProcess/WebInspectorProxy.h:
+        * UIProcess/WebMediaCacheManagerProxy.h:
+        * UIProcess/WebOriginDataManagerProxy.h:
+        * UIProcess/WebPageProxy.cpp:
+        (WebKit::WebPageProxy::willGoToBackForwardListItem):
+        (WebKit::WebPageProxy::preferencesDidChange):
+        (WebKit::WebPageProxy::didStartProvisionalLoadForFrame):
+        (WebKit::WebPageProxy::didReceiveServerRedirectForProvisionalLoadForFrame):
+        (WebKit::WebPageProxy::didFailProvisionalLoadForFrame):
+        (WebKit::WebPageProxy::didCommitLoadForFrame):
+        (WebKit::WebPageProxy::didFinishDocumentLoadForFrame):
+        (WebKit::WebPageProxy::didFinishLoadForFrame):
+        (WebKit::WebPageProxy::didFailLoadForFrame):
+        (WebKit::WebPageProxy::didSameDocumentNavigationForFrame):
+        (WebKit::WebPageProxy::didReceiveTitleForFrame):
+        (WebKit::WebPageProxy::didFirstLayoutForFrame):
+        (WebKit::WebPageProxy::didFirstVisuallyNonEmptyLayoutForFrame):
+        (WebKit::WebPageProxy::didLayout):
+        (WebKit::WebPageProxy::didRemoveFrameFromHierarchy):
+        (WebKit::WebPageProxy::didDisplayInsecureContentForFrame):
+        (WebKit::WebPageProxy::didRunInsecureContentForFrame):
+        (WebKit::WebPageProxy::didDetectXSSForFrame):
+        (WebKit::WebPageProxy::decidePolicyForNavigationAction):
+        (WebKit::WebPageProxy::decidePolicyForNewWindowAction):
+        (WebKit::WebPageProxy::decidePolicyForResponse):
+        (WebKit::WebPageProxy::decidePolicyForResponseSync):
+        (WebKit::WebPageProxy::unableToImplementPolicy):
+        (WebKit::WebPageProxy::willSubmitForm):
+        (WebKit::WebPageProxy::mouseDidMoveOverElement):
+        (WebKit::WebPageProxy::connectionWillOpen):
+        (WebKit::WebPageProxy::connectionWillClose):
+        (WebKit::WebPageProxy::sendMessage):
+        (WebKit::WebPageProxy::messageSenderConnection):
+        (WebKit::WebPageProxy::showContextMenu):
+        (WebKit::WebPageProxy::internalShowContextMenu):
+        (WebKit::WebPageProxy::dataCallback):
+        (WebKit::WebPageProxy::scriptValueCallback):
+        (WebKit::WebPageProxy::beginPrinting):
+        (WebKit::WebPageProxy::endPrinting):
+        (WebKit::WebPageProxy::computePagesForPrinting):
+        (WebKit::WebPageProxy::drawRectToImage):
+        (WebKit::WebPageProxy::drawPagesToPDF):
+        (WebKit::WebPageProxy::drawPagesForPrinting):
+        (WebKit::WebPageProxy::savePDFToFileInDownloadsFolder):
+        * UIProcess/WebPageProxy.h:
+        * UIProcess/WebPageProxy.messages.in:
+        * UIProcess/WebProcessProxy.cpp:
+        (WebKit::WebProcessProxy::connectionWillOpen):
+        (WebKit::WebProcessProxy::connectionWillClose):
+        (WebKit::WebProcessProxy::addBackForwardItem):
+        (WebKit::WebProcessProxy::didReceiveMessage):
+        (WebKit::WebProcessProxy::didReceiveSyncMessage):
+        (WebKit::WebProcessProxy::didClose):
+        (WebKit::WebProcessProxy::didReceiveInvalidMessage):
+        (WebKit::WebProcessProxy::didFinishLaunching):
+        * UIProcess/WebProcessProxy.h:
+        (WebKit::WebProcessProxy::fromConnection):
+        * UIProcess/WebProcessProxy.messages.in:
+        * UIProcess/WebResourceCacheManagerProxy.h:
+        * UIProcess/cf/WebBackForwardListCF.cpp:
+        (WebKit::WebBackForwardList::createCFDictionaryRepresentation):
+        * UIProcess/mac/RemoteLayerTreeHost.h:
+        * UIProcess/mac/SecItemShimProxy.cpp:
+        (WebKit::SecItemShimProxy::initializeConnection):
+        (WebKit::SecItemShimProxy::secItemRequest):
+        * UIProcess/mac/SecItemShimProxy.h:
+        * UIProcess/mac/ViewGestureController.h:
+        * UIProcess/mac/WebContextMac.mm:
+        (WebKit::WebContext::platformInitializeWebProcess):
+        * UIProcess/mac/WebPageProxyMac.mm:
+        (WebKit::WebPageProxy::registerWebProcessAccessibilityToken):
+        (WebKit::WebPageProxy::registerUIProcessAccessibilityTokens):
+        (WebKit::WebPageProxy::savePDFToTemporaryFolderAndOpenWithNativeApplication):
+        * WebKit2.xcodeproj/project.pbxproj:
+        * WebProcess/ApplicationCache/WebApplicationCacheManager.h:
+        * WebProcess/Cookies/WebCookieManager.h:
+        * WebProcess/Databases/IndexedDB/WebIDBServerConnection.cpp:
+        (WebKit::WebIDBServerConnection::messageSenderConnection):
+        * WebProcess/Databases/IndexedDB/WebIDBServerConnection.h:
+        * WebProcess/Databases/WebToDatabaseProcessConnection.cpp:
+        (WebKit::WebToDatabaseProcessConnection::WebToDatabaseProcessConnection):
+        (WebKit::WebToDatabaseProcessConnection::didReceiveMessage):
+        (WebKit::WebToDatabaseProcessConnection::didClose):
+        (WebKit::WebToDatabaseProcessConnection::didReceiveInvalidMessage):
+        * WebProcess/Databases/WebToDatabaseProcessConnection.h:
+        (WebKit::WebToDatabaseProcessConnection::create):
+        (WebKit::WebToDatabaseProcessConnection::connection):
+        * WebProcess/EntryPoint/mac/LegacyProcess/WebContentProcessMain.mm:
+        (WebKit::WebContentProcessMainDelegate::getConnectionIdentifier):
+        * WebProcess/FullScreen/WebFullScreenManager.cpp:
+        (WebKit::WebFullScreenManager::didReceiveMessage):
+        * WebProcess/FullScreen/WebFullScreenManager.h:
+        * WebProcess/Geolocation/WebGeolocationManager.h:
+        * WebProcess/IconDatabase/WebIconDatabaseProxy.cpp:
+        (WebKit::WebIconDatabaseProxy::synchronousIconForPageURL):
+        (WebKit::WebIconDatabaseProxy::setIconDataForIconURL):
+        * WebProcess/IconDatabase/WebIconDatabaseProxy.h:
+        * WebProcess/InjectedBundle/InjectedBundle.cpp:
+        (WebKit::InjectedBundle::postMessage):
+        (WebKit::InjectedBundle::postSynchronousMessage):
+        * WebProcess/InjectedBundle/InjectedBundleUserMessageCoders.h:
+        (WebKit::InjectedBundleUserMessageEncoder::encode):
+        (WebKit::InjectedBundleUserMessageDecoder::decode):
+        * WebProcess/MediaCache/WebMediaCacheManager.h:
+        * WebProcess/Network/NetworkProcessConnection.cpp:
+        (WebKit::NetworkProcessConnection::NetworkProcessConnection):
+        (WebKit::NetworkProcessConnection::didReceiveMessage):
+        (WebKit::NetworkProcessConnection::didReceiveSyncMessage):
+        (WebKit::NetworkProcessConnection::didClose):
+        (WebKit::NetworkProcessConnection::didReceiveInvalidMessage):
+        * WebProcess/Network/NetworkProcessConnection.h:
+        (WebKit::NetworkProcessConnection::create):
+        (WebKit::NetworkProcessConnection::connection):
+        * WebProcess/Network/WebResourceLoader.cpp:
+        (WebKit::WebResourceLoader::messageSenderConnection):
+        (WebKit::WebResourceLoader::didReceiveData):
+        * WebProcess/Network/WebResourceLoader.h:
+        * WebProcess/Network/WebResourceLoader.messages.in:
+        * WebProcess/Notifications/WebNotificationManager.h:
+        * WebProcess/OriginData/WebOriginDataManager.h:
+        * WebProcess/Plugins/PDF/PDFPlugin.h:
+        * WebProcess/Plugins/Plugin.cpp:
+        (WebKit::Plugin::Parameters::encode):
+        (WebKit::Plugin::Parameters::decode):
+        * WebProcess/Plugins/Plugin.h:
+        * WebProcess/Plugins/PluginProcessConnection.cpp:
+        (WebKit::PluginProcessConnection::PluginProcessConnection):
+        (WebKit::PluginProcessConnection::didReceiveMessage):
+        (WebKit::PluginProcessConnection::didReceiveSyncMessage):
+        (WebKit::PluginProcessConnection::didClose):
+        (WebKit::PluginProcessConnection::didReceiveInvalidMessage):
+        * WebProcess/Plugins/PluginProcessConnection.h:
+        (WebKit::PluginProcessConnection::create):
+        (WebKit::PluginProcessConnection::connection):
+        * WebProcess/Plugins/PluginProcessConnectionManager.cpp:
+        (WebKit::PluginProcessConnectionManager::initializeConnection):
+        (WebKit::PluginProcessConnectionManager::getPluginProcessConnection):
+        (WebKit::PluginProcessConnectionManager::pluginProcessCrashed):
+        * WebProcess/Plugins/PluginProcessConnectionManager.h:
+        * WebProcess/Plugins/PluginProxy.cpp:
+        (WebKit::PluginProxy::geometryDidChange):
+        (WebKit::PluginProxy::streamDidReceiveData):
+        (WebKit::PluginProxy::manualStreamDidReceiveData):
+        * WebProcess/Plugins/PluginProxy.h:
+        * WebProcess/ResourceCache/WebResourceCacheManager.h:
+        * WebProcess/Storage/StorageAreaMap.h:
+        * WebProcess/WebConnectionToUIProcess.cpp:
+        (WebKit::WebConnectionToUIProcess::encodeMessageBody):
+        (WebKit::WebConnectionToUIProcess::decodeMessageBody):
+        (WebKit::WebConnectionToUIProcess::messageSenderConnection):
+        * WebProcess/WebConnectionToUIProcess.h:
+        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
+        (WebKit::WebChromeClient::runJavaScriptAlert):
+        (WebKit::WebChromeClient::runJavaScriptConfirm):
+        (WebKit::WebChromeClient::runJavaScriptPrompt):
+        * WebProcess/WebCoreSupport/WebDatabaseManager.h:
+        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
+        (WebKit::WebFrameLoaderClient::dispatchDecidePolicyForResponse):
+        * WebProcess/WebPage/DecoderAdapter.cpp:
+        (WebKit::DecoderAdapter::decodeBytes):
+        (WebKit::DecoderAdapter::decodeString):
+        * WebProcess/WebPage/DecoderAdapter.h:
+        * WebProcess/WebPage/DrawingArea.h:
+        * WebProcess/WebPage/EncoderAdapter.cpp:
+        (WebKit::EncoderAdapter::dataReference):
+        (WebKit::EncoderAdapter::encodeBytes):
+        (WebKit::EncoderAdapter::encodeString):
+        * WebProcess/WebPage/EncoderAdapter.h:
+        * WebProcess/WebPage/EventDispatcher.cpp:
+        (WebKit::EventDispatcher::initializeConnection):
+        * WebProcess/WebPage/EventDispatcher.h:
+        * WebProcess/WebPage/LayerTreeHost.h:
+        * WebProcess/WebPage/ViewGestureGeometryCollector.h:
+        * WebProcess/WebPage/WebInspector.cpp:
+        (WebKit::WebInspector::createInspectorPage):
+        * WebProcess/WebPage/WebInspector.h:
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::messageSenderConnection):
+        (WebKit::WebPage::loadURL):
+        (WebKit::WebPage::loadURLRequest):
+        (WebKit::WebPage::loadDataImpl):
+        (WebKit::WebPage::loadString):
+        (WebKit::WebPage::loadData):
+        (WebKit::WebPage::loadHTMLString):
+        (WebKit::WebPage::loadAlternateHTMLString):
+        (WebKit::WebPage::loadPlainTextString):
+        (WebKit::WebPage::loadWebArchiveData):
+        (WebKit::WebPage::postInjectedBundleMessage):
+        (WebKit::WebPage::runJavaScriptInMainFrame):
+        (WebKit::WebPage::getContentsAsMHTMLData):
+        (WebKit::WebPage::getSelectionAsWebArchiveData):
+        (WebKit::WebPage::getMainResourceDataOfFrame):
+        (WebKit::WebPage::getResourceDataFromFrame):
+        (WebKit::WebPage::getWebArchiveOfFrame):
+        (WebKit::WebPage::didReceiveMessage):
+        (WebKit::WebPage::didReceiveSyncMessage):
+        (WebKit::WebPage::drawPagesToPDF):
+        (WebKit::WebPage::savePDFToFileInDownloadsFolder):
+        (WebKit::WebPage::savePDFToTemporaryFolderAndOpenWithNativeApplication):
+        * WebProcess/WebPage/WebPage.h:
+        * WebProcess/WebPage/WebPage.messages.in:
+        * WebProcess/WebPage/WebPageGroupProxy.h:
+        * WebProcess/WebPage/mac/WebPageMac.mm:
+        (WebKit::WebPage::platformInitialize):
+        (WebKit::WebPage::registerUIProcessAccessibilityTokens):
+        * WebProcess/WebProcess.cpp:
+        (WebKit::WebProcess::initializeConnection):
+        (WebKit::WebProcess::downloadProxyConnection):
+        (WebKit::WebProcess::initializeWebProcess):
+        (WebKit::WebProcess::ensureNetworkProcessConnection):
+        (WebKit::WebProcess::didReceiveSyncMessage):
+        (WebKit::WebProcess::didReceiveMessage):
+        (WebKit::WebProcess::didClose):
+        (WebKit::WebProcess::didReceiveInvalidMessage):
+        (WebKit::WebProcess::postInjectedBundleMessage):
+        (WebKit::WebProcess::ensureWebToDatabaseProcessConnection):
+        * WebProcess/WebProcess.h:
+        * WebProcess/WebProcess.messages.in:
+        * WebProcess/mac/WebProcessMac.mm:
+        (WebKit::WebProcess::platformInitializeWebProcess):
+        * config.h:
+
+2013-12-30  Anders Carlsson  <andersca@apple.com>
+
          Move remaining IPC related files to Platform/IPC.
  
          Rubber-stamped by Andreas Kling.
diff --git a/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp b/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp

index eb57245..90457fd 100644 (file)
--- a/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp
+++ b/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp
@@ -55,7 +55,7 @@ DatabaseProcess::~DatabaseProcess()
  {
  }
  
-void DatabaseProcess::initializeConnection(CoreIPC::Connection* connection)
+void DatabaseProcess::initializeConnection(IPC::Connection* connection)
  {
      ChildProcess::initializeConnection(connection);
  }
@@ -65,12 +65,12 @@ bool DatabaseProcess::shouldTerminate()
      return true;
  }
  
-void DatabaseProcess::didClose(CoreIPC::Connection*)
+void DatabaseProcess::didClose(IPC::Connection*)
  {
      RunLoop::current()->stop();
  }
  
-void DatabaseProcess::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference, CoreIPC::StringReference)
+void DatabaseProcess::didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference, IPC::StringReference)
  {
      RunLoop::current()->stop();
  }
@@ -155,10 +155,10 @@ void DatabaseProcess::createDatabaseToWebProcessConnection()
      mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &listeningPort);
  
      // Create a listening connection.
-    RefPtr<DatabaseToWebProcessConnection> connection = DatabaseToWebProcessConnection::create(CoreIPC::Connection::Identifier(listeningPort));
+    RefPtr<DatabaseToWebProcessConnection> connection = DatabaseToWebProcessConnection::create(IPC::Connection::Identifier(listeningPort));
      m_databaseToWebProcessConnections.append(connection.release());
  
-    CoreIPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
+    IPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
      parentProcessConnection()->send(Messages::DatabaseProcessProxy::DidCreateDatabaseToWebProcessConnection(clientPort), 0);
  #else
      notImplemented();
diff --git a/Source/WebKit2/DatabaseProcess/DatabaseProcess.h b/Source/WebKit2/DatabaseProcess/DatabaseProcess.h

index 5d5d841..24b1ef0 100644 (file)
--- a/Source/WebKit2/DatabaseProcess/DatabaseProcess.h
+++ b/Source/WebKit2/DatabaseProcess/DatabaseProcess.h
@@ -67,13 +67,13 @@ private:
      virtual void initializeProcess(const ChildProcessInitializationParameters&) OVERRIDE;
      virtual void initializeProcessName(const ChildProcessInitializationParameters&) OVERRIDE;
      virtual void initializeSandbox(const ChildProcessInitializationParameters&, SandboxInitializationParameters&) OVERRIDE;
-    virtual void initializeConnection(CoreIPC::Connection*) OVERRIDE;
+    virtual void initializeConnection(IPC::Connection*) OVERRIDE;
      virtual bool shouldTerminate() OVERRIDE;
  
-    // CoreIPC::Connection::Client
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
-    virtual void didClose(CoreIPC::Connection*) OVERRIDE;
-    virtual void didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference messageReceiverName, CoreIPC::StringReference messageName) OVERRIDE;
+    // IPC::Connection::Client
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) OVERRIDE;
+    virtual void didClose(IPC::Connection*) OVERRIDE;
+    virtual void didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference messageReceiverName, IPC::StringReference messageName) OVERRIDE;
  
      // Message Handlers
      void initializeDatabaseProcess(const DatabaseProcessCreationParameters&);
diff --git a/Source/WebKit2/DatabaseProcess/DatabaseToWebProcessConnection.cpp b/Source/WebKit2/DatabaseProcess/DatabaseToWebProcessConnection.cpp

index 28773fc..7f90c43 100644 (file)
--- a/Source/WebKit2/DatabaseProcess/DatabaseToWebProcessConnection.cpp
+++ b/Source/WebKit2/DatabaseProcess/DatabaseToWebProcessConnection.cpp
@@ -35,14 +35,14 @@
  
  namespace WebKit {
  
-PassRefPtr<DatabaseToWebProcessConnection> DatabaseToWebProcessConnection::create(CoreIPC::Connection::Identifier connectionIdentifier)
+PassRefPtr<DatabaseToWebProcessConnection> DatabaseToWebProcessConnection::create(IPC::Connection::Identifier connectionIdentifier)
  {
      return adoptRef(new DatabaseToWebProcessConnection(connectionIdentifier));
  }
  
-DatabaseToWebProcessConnection::DatabaseToWebProcessConnection(CoreIPC::Connection::Identifier connectionIdentifier)
+DatabaseToWebProcessConnection::DatabaseToWebProcessConnection(IPC::Connection::Identifier connectionIdentifier)
  {
-    m_connection = CoreIPC::Connection::createServerConnection(connectionIdentifier, this, RunLoop::main());
+    m_connection = IPC::Connection::createServerConnection(connectionIdentifier, this, RunLoop::main());
      m_connection->setOnlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage(true);
      m_connection->open();
  }
@@ -52,7 +52,7 @@ DatabaseToWebProcessConnection::~DatabaseToWebProcessConnection()
  
  }
  
-void DatabaseToWebProcessConnection::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
+void DatabaseToWebProcessConnection::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
  {
      if (decoder.messageReceiverName() == Messages::DatabaseToWebProcessConnection::messageReceiverName()) {
          didReceiveDatabaseToWebProcessConnectionMessage(connection, decoder);
@@ -69,12 +69,12 @@ void DatabaseToWebProcessConnection::didReceiveMessage(CoreIPC::Connection* conn
      ASSERT_NOT_REACHED();
  }
  
-void DatabaseToWebProcessConnection::didClose(CoreIPC::Connection*)
+void DatabaseToWebProcessConnection::didClose(IPC::Connection*)
  {
  
  }
  
-void DatabaseToWebProcessConnection::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference messageReceiverName, CoreIPC::StringReference messageName)
+void DatabaseToWebProcessConnection::didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference messageReceiverName, IPC::StringReference messageName)
  {
  
  }
diff --git a/Source/WebKit2/DatabaseProcess/DatabaseToWebProcessConnection.h b/Source/WebKit2/DatabaseProcess/DatabaseToWebProcessConnection.h

index 96ec0b5..78d885c 100644 (file)
--- a/Source/WebKit2/DatabaseProcess/DatabaseToWebProcessConnection.h
+++ b/Source/WebKit2/DatabaseProcess/DatabaseToWebProcessConnection.h
@@ -36,24 +36,24 @@
  
  namespace WebKit {
  
-class DatabaseToWebProcessConnection : public RefCounted<DatabaseToWebProcessConnection>, public CoreIPC::Connection::Client, public CoreIPC::MessageSender {
+class DatabaseToWebProcessConnection : public RefCounted<DatabaseToWebProcessConnection>, public IPC::Connection::Client, public IPC::MessageSender {
  public:
-    static PassRefPtr<DatabaseToWebProcessConnection> create(CoreIPC::Connection::Identifier);
+    static PassRefPtr<DatabaseToWebProcessConnection> create(IPC::Connection::Identifier);
      ~DatabaseToWebProcessConnection();
  
-    CoreIPC::Connection* connection() const { return m_connection.get(); }
+    IPC::Connection* connection() const { return m_connection.get(); }
  
  private:
-    DatabaseToWebProcessConnection(CoreIPC::Connection::Identifier);
+    DatabaseToWebProcessConnection(IPC::Connection::Identifier);
  
-    // CoreIPC::Connection::Client
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
-    virtual void didClose(CoreIPC::Connection*) OVERRIDE;
-    virtual void didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference messageReceiverName, CoreIPC::StringReference messageName) OVERRIDE;
-    void didReceiveDatabaseToWebProcessConnectionMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
+    // IPC::Connection::Client
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) OVERRIDE;
+    virtual void didClose(IPC::Connection*) OVERRIDE;
+    virtual void didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference messageReceiverName, IPC::StringReference messageName) OVERRIDE;
+    void didReceiveDatabaseToWebProcessConnectionMessage(IPC::Connection*, IPC::MessageDecoder&);
  
-    // CoreIPC::MessageSender
-    virtual CoreIPC::Connection* messageSenderConnection() OVERRIDE { return m_connection.get(); }
+    // IPC::MessageSender
+    virtual IPC::Connection* messageSenderConnection() OVERRIDE { return m_connection.get(); }
      virtual uint64_t messageSenderDestinationID() OVERRIDE { return 0; }
  
  #if ENABLE(INDEXED_DATABASE)
@@ -65,7 +65,7 @@ private:
      IDBConnectionMap m_idbConnections;
  #endif // ENABLE(INDEXED_DATABASE)
  
-    RefPtr<CoreIPC::Connection> m_connection;
+    RefPtr<IPC::Connection> m_connection;
  };
  
  } // namespace WebKit
diff --git a/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp b/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp

index 887d6d3..dbd9e00 100644 (file)
--- a/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp
+++ b/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp
@@ -155,7 +155,7 @@ void DatabaseProcessIDBConnection::changeDatabaseVersion(uint64_t requestID, int
      });
  }
  
-CoreIPC::Connection* DatabaseProcessIDBConnection::messageSenderConnection()
+IPC::Connection* DatabaseProcessIDBConnection::messageSenderConnection()
  {
      return m_connection->connection();
  }
diff --git a/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h b/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h

index ad62eb7..64754ec 100644 (file)
--- a/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h
+++ b/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h
@@ -39,7 +39,7 @@ namespace WebKit {
  class DatabaseToWebProcessConnection;
  class UniqueIDBDatabase;
  
-class DatabaseProcessIDBConnection : public RefCounted<DatabaseProcessIDBConnection>, public CoreIPC::MessageSender {
+class DatabaseProcessIDBConnection : public RefCounted<DatabaseProcessIDBConnection>, public IPC::MessageSender {
  public:
      static RefPtr<DatabaseProcessIDBConnection> create(DatabaseToWebProcessConnection& connection, uint64_t serverConnectionIdentifier)
      {
@@ -49,15 +49,15 @@ public:
      virtual ~DatabaseProcessIDBConnection();
  
      // Message handlers.
-    void didReceiveDatabaseProcessIDBConnectionMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
+    void didReceiveDatabaseProcessIDBConnectionMessage(IPC::Connection*, IPC::MessageDecoder&);
  
      void disconnectedFromWebProcess();
  
  private:
      DatabaseProcessIDBConnection(DatabaseToWebProcessConnection&, uint64_t idbConnectionIdentifier);
  
-    // CoreIPC::MessageSender
-    virtual CoreIPC::Connection* messageSenderConnection() OVERRIDE;
+    // IPC::MessageSender
+    virtual IPC::Connection* messageSenderConnection() OVERRIDE;
      virtual uint64_t messageSenderDestinationID() OVERRIDE { return m_serverConnectionIdentifier; }
  
      // Message handlers.
diff --git a/Source/WebKit2/NetworkProcess/AsynchronousNetworkLoaderClient.cpp b/Source/WebKit2/NetworkProcess/AsynchronousNetworkLoaderClient.cpp

index d1c93d4..3cb5cb4 100644 (file)
--- a/Source/WebKit2/NetworkProcess/AsynchronousNetworkLoaderClient.cpp
+++ b/Source/WebKit2/NetworkProcess/AsynchronousNetworkLoaderClient.cpp
@@ -49,7 +49,7 @@ void AsynchronousNetworkLoaderClient::willSendRequest(NetworkResourceLoader* loa
  {
      // This message is DispatchMessageEvenWhenWaitingForSyncReply to avoid a situation where the NetworkProcess is deadlocked
      // waiting for 6 connections to complete while the WebProcess is waiting for a 7th (Synchronous XHR) to complete.
-    loader->sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(request, redirectResponse), CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply);
+    loader->sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(request, redirectResponse), IPC::DispatchMessageEvenWhenWaitingForSyncReply);
  }
  
  #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
@@ -57,7 +57,7 @@ void AsynchronousNetworkLoaderClient::canAuthenticateAgainstProtectionSpace(Netw
  {
      // This message is DispatchMessageEvenWhenWaitingForSyncReply to avoid a situation where the NetworkProcess is deadlocked
      // waiting for 6 connections to complete while the WebProcess is waiting for a 7th (Synchronous XHR) to complete.
-    loader->sendAbortingOnFailure(Messages::WebResourceLoader::CanAuthenticateAgainstProtectionSpace(protectionSpace), CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply);
+    loader->sendAbortingOnFailure(Messages::WebResourceLoader::CanAuthenticateAgainstProtectionSpace(protectionSpace), IPC::DispatchMessageEvenWhenWaitingForSyncReply);
  }
  #endif
  
@@ -79,7 +79,7 @@ void AsynchronousNetworkLoaderClient::didReceiveBuffer(NetworkResourceLoader* lo
      }
  #endif // __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
  
-    CoreIPC::DataReference dataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
+    IPC::DataReference dataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
      loader->sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));
  }
  
diff --git a/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.cpp b/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.cpp

index 93ccdb3..f599446 100644 (file)
--- a/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.cpp
+++ b/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.cpp
@@ -47,15 +47,15 @@ using namespace WebCore;
  
  namespace WebKit {
  
-PassRefPtr<NetworkConnectionToWebProcess> NetworkConnectionToWebProcess::create(CoreIPC::Connection::Identifier connectionIdentifier)
+PassRefPtr<NetworkConnectionToWebProcess> NetworkConnectionToWebProcess::create(IPC::Connection::Identifier connectionIdentifier)
  {
      return adoptRef(new NetworkConnectionToWebProcess(connectionIdentifier));
  }
  
-NetworkConnectionToWebProcess::NetworkConnectionToWebProcess(CoreIPC::Connection::Identifier connectionIdentifier)
+NetworkConnectionToWebProcess::NetworkConnectionToWebProcess(IPC::Connection::Identifier connectionIdentifier)
      : m_serialLoadingEnabled(false)
  {
-    m_connection = CoreIPC::Connection::createServerConnection(connectionIdentifier, this, RunLoop::main());
+    m_connection = IPC::Connection::createServerConnection(connectionIdentifier, this, RunLoop::main());
      m_connection->setOnlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage(true);
      m_connection->open();
  }
@@ -64,7 +64,7 @@ NetworkConnectionToWebProcess::~NetworkConnectionToWebProcess()
  {
  }
      
-void NetworkConnectionToWebProcess::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
+void NetworkConnectionToWebProcess::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
  {
      if (decoder.messageReceiverName() == Messages::NetworkConnectionToWebProcess::messageReceiverName()) {
          didReceiveNetworkConnectionToWebProcessMessage(connection, decoder);
@@ -81,7 +81,7 @@ void NetworkConnectionToWebProcess::didReceiveMessage(CoreIPC::Connection* conne
      ASSERT_NOT_REACHED();
  }
  
-void NetworkConnectionToWebProcess::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& reply)
+void NetworkConnectionToWebProcess::didReceiveSyncMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& reply)
  {
      if (decoder.messageReceiverName() == Messages::NetworkConnectionToWebProcess::messageReceiverName()) {
          didReceiveSyncNetworkConnectionToWebProcessMessage(connection, decoder, reply);
@@ -90,7 +90,7 @@ void NetworkConnectionToWebProcess::didReceiveSyncMessage(CoreIPC::Connection* c
      ASSERT_NOT_REACHED();
  }
  
-void NetworkConnectionToWebProcess::didClose(CoreIPC::Connection*)
+void NetworkConnectionToWebProcess::didClose(IPC::Connection*)
  {
      // Protect ourself as we might be otherwise be deleted during this function.
      Ref<NetworkConnectionToWebProcess> protector(*this);
@@ -106,7 +106,7 @@ void NetworkConnectionToWebProcess::didClose(CoreIPC::Connection*)
      NetworkProcess::shared().removeNetworkConnectionToWebProcess(this);
  }
  
-void NetworkConnectionToWebProcess::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference, CoreIPC::StringReference)
+void NetworkConnectionToWebProcess::didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference, IPC::StringReference)
  {
  }
  
diff --git a/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h b/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h

index d22dd53..9457375 100644 (file)
--- a/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h
+++ b/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h
@@ -47,27 +47,27 @@ class NetworkResourceLoader;
  class SyncNetworkResourceLoader;
  typedef uint64_t ResourceLoadIdentifier;
  
-class NetworkConnectionToWebProcess : public RefCounted<NetworkConnectionToWebProcess>, CoreIPC::Connection::Client {
+class NetworkConnectionToWebProcess : public RefCounted<NetworkConnectionToWebProcess>, IPC::Connection::Client {
  public:
-    static PassRefPtr<NetworkConnectionToWebProcess> create(CoreIPC::Connection::Identifier);
+    static PassRefPtr<NetworkConnectionToWebProcess> create(IPC::Connection::Identifier);
      virtual ~NetworkConnectionToWebProcess();
  
-    CoreIPC::Connection* connection() const { return m_connection.get(); }
+    IPC::Connection* connection() const { return m_connection.get(); }
  
      bool isSerialLoadingEnabled() const { return m_serialLoadingEnabled; }
  
  private:
-    NetworkConnectionToWebProcess(CoreIPC::Connection::Identifier);
+    NetworkConnectionToWebProcess(IPC::Connection::Identifier);
  
-    // CoreIPC::Connection::Client
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
-    virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&);
-    virtual void didClose(CoreIPC::Connection*);
-    virtual void didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference messageReceiverName, CoreIPC::StringReference messageName);
+    // IPC::Connection::Client
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&);
+    virtual void didReceiveSyncMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
+    virtual void didClose(IPC::Connection*);
+    virtual void didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference messageReceiverName, IPC::StringReference messageName);
  
      // Message handlers.
-    void didReceiveNetworkConnectionToWebProcessMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
-    void didReceiveSyncNetworkConnectionToWebProcessMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&);
+    void didReceiveNetworkConnectionToWebProcessMessage(IPC::Connection*, IPC::MessageDecoder&);
+    void didReceiveSyncNetworkConnectionToWebProcessMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
      
      void scheduleResourceLoad(const NetworkResourceLoadParameters&);
      void performSynchronousLoad(const NetworkResourceLoadParameters&, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
@@ -90,7 +90,7 @@ private:
      void registerBlobURLFromURL(const WebCore::URL&, const WebCore::URL& srcURL);
      void unregisterBlobURL(const WebCore::URL&);
  
-    RefPtr<CoreIPC::Connection> m_connection;
+    RefPtr<IPC::Connection> m_connection;
  
      HashMap<ResourceLoadIdentifier, RefPtr<NetworkResourceLoader>> m_networkResourceLoaders;
  
diff --git a/Source/WebKit2/NetworkProcess/NetworkProcess.cpp b/Source/WebKit2/NetworkProcess/NetworkProcess.cpp

index c599670..e5000f5 100644 (file)
--- a/Source/WebKit2/NetworkProcess/NetworkProcess.cpp
+++ b/Source/WebKit2/NetworkProcess/NetworkProcess.cpp
@@ -106,7 +106,7 @@ bool NetworkProcess::shouldTerminate()
      return false;
  }
  
-void NetworkProcess::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
+void NetworkProcess::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
  {
      if (messageReceiverMap().dispatchMessage(connection, decoder))
          return;
@@ -114,18 +114,18 @@ void NetworkProcess::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC:
      didReceiveNetworkProcessMessage(connection, decoder);
  }
  
-void NetworkProcess::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)
+void NetworkProcess::didReceiveSyncMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
  {
      messageReceiverMap().dispatchSyncMessage(connection, decoder, replyEncoder);
  }
  
-void NetworkProcess::didClose(CoreIPC::Connection*)
+void NetworkProcess::didClose(IPC::Connection*)
  {
      // The UIProcess just exited.
      RunLoop::current()->stop();
  }
  
-void NetworkProcess::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference, CoreIPC::StringReference)
+void NetworkProcess::didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference, IPC::StringReference)
  {
      RunLoop::current()->stop();
  }
@@ -140,7 +140,7 @@ void NetworkProcess::didDestroyDownload()
      enableTermination();
  }
  
-CoreIPC::Connection* NetworkProcess::downloadProxyConnection()
+IPC::Connection* NetworkProcess::downloadProxyConnection()
  {
      return parentProcessConnection();
  }
@@ -172,7 +172,7 @@ void NetworkProcess::initializeNetworkProcess(const NetworkProcessCreationParame
          it->value->initialize(parameters);
  }
  
-void NetworkProcess::initializeConnection(CoreIPC::Connection* connection)
+void NetworkProcess::initializeConnection(IPC::Connection* connection)
  {
      ChildProcess::initializeConnection(connection);
  
@@ -194,18 +194,18 @@ void NetworkProcess::createNetworkConnectionToWebProcess()
      mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &listeningPort);
  
      // Create a listening connection.
-    RefPtr<NetworkConnectionToWebProcess> connection = NetworkConnectionToWebProcess::create(CoreIPC::Connection::Identifier(listeningPort));
+    RefPtr<NetworkConnectionToWebProcess> connection = NetworkConnectionToWebProcess::create(IPC::Connection::Identifier(listeningPort));
      m_webProcessConnections.append(connection.release());
  
-    CoreIPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
+    IPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
      parentProcessConnection()->send(Messages::NetworkProcessProxy::DidCreateNetworkConnectionToWebProcess(clientPort), 0);
  #elif USE(UNIX_DOMAIN_SOCKETS)
-    CoreIPC::Connection::SocketPair socketPair = CoreIPC::Connection::createPlatformConnection();
+    IPC::Connection::SocketPair socketPair = IPC::Connection::createPlatformConnection();
  
      RefPtr<NetworkConnectionToWebProcess> connection = NetworkConnectionToWebProcess::create(socketPair.server);
      m_webProcessConnections.append(connection.release());
  
-    CoreIPC::Attachment clientSocket(socketPair.client);
+    IPC::Attachment clientSocket(socketPair.client);
      parentProcessConnection()->send(Messages::NetworkProcessProxy::DidCreateNetworkConnectionToWebProcess(clientSocket), 0);
  #else
      notImplemented();
diff --git a/Source/WebKit2/NetworkProcess/NetworkProcess.h b/Source/WebKit2/NetworkProcess/NetworkProcess.h

index 5b224fd..7daad31 100644 (file)
--- a/Source/WebKit2/NetworkProcess/NetworkProcess.h
+++ b/Source/WebKit2/NetworkProcess/NetworkProcess.h
@@ -85,23 +85,23 @@ private:
      virtual void initializeProcess(const ChildProcessInitializationParameters&) OVERRIDE;
      virtual void initializeProcessName(const ChildProcessInitializationParameters&) OVERRIDE;
      virtual void initializeSandbox(const ChildProcessInitializationParameters&, SandboxInitializationParameters&) OVERRIDE;
-    virtual void initializeConnection(CoreIPC::Connection*) OVERRIDE;
+    virtual void initializeConnection(IPC::Connection*) OVERRIDE;
      virtual bool shouldTerminate() OVERRIDE;
  
-    // CoreIPC::Connection::Client
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
-    virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&);
-    virtual void didClose(CoreIPC::Connection*) OVERRIDE;
-    virtual void didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference messageReceiverName, CoreIPC::StringReference messageName) OVERRIDE;
+    // IPC::Connection::Client
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) OVERRIDE;
+    virtual void didReceiveSyncMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
+    virtual void didClose(IPC::Connection*) OVERRIDE;
+    virtual void didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference messageReceiverName, IPC::StringReference messageName) OVERRIDE;
  
      // DownloadManager::Client
      virtual void didCreateDownload() OVERRIDE;
      virtual void didDestroyDownload() OVERRIDE;
-    virtual CoreIPC::Connection* downloadProxyConnection() OVERRIDE;
+    virtual IPC::Connection* downloadProxyConnection() OVERRIDE;
      virtual AuthenticationManager& downloadsAuthenticationManager() OVERRIDE;
  
      // Message Handlers
-    void didReceiveNetworkProcessMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
+    void didReceiveNetworkProcessMessage(IPC::Connection*, IPC::MessageDecoder&);
      void initializeNetworkProcess(const NetworkProcessCreationParameters&);
      void createNetworkConnectionToWebProcess();
      void ensurePrivateBrowsingSession();
diff --git a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

index 96379b9..0738929 100644 (file)
--- a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp
+++ b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp
@@ -336,7 +336,7 @@ void NetworkResourceLoader::didCancelAuthenticationChallenge(ResourceHandle* han
      notImplemented();
  }
  
-CoreIPC::Connection* NetworkResourceLoader::messageSenderConnection()
+IPC::Connection* NetworkResourceLoader::messageSenderConnection()
  {
      return connectionToWebProcess()->connection();
  }
diff --git a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h

index 189698d..9d23032 100644 (file)
--- a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h
+++ b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h
@@ -54,7 +54,7 @@ class NetworkResourceLoadParameters;
  class RemoteNetworkingContext;
  class SandboxExtension;
  
-class NetworkResourceLoader : public RefCounted<NetworkResourceLoader>, public WebCore::ResourceHandleClient, public CoreIPC::MessageSender {
+class NetworkResourceLoader : public RefCounted<NetworkResourceLoader>, public WebCore::ResourceHandleClient, public IPC::MessageSender {
  public:
      static RefPtr<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection)
      {
@@ -112,7 +112,7 @@ public:
  #endif // PLATFORM(MAC)
  
      // Message handlers.
-    void didReceiveNetworkResourceLoaderMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
+    void didReceiveNetworkResourceLoaderMessage(IPC::Connection*, IPC::MessageDecoder&);
  
  #if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
      static void tryGetShareableHandleFromCFURLCachedResponse(ShareableResource::Handle&, CFCachedURLResponseRef);
@@ -146,8 +146,8 @@ public:
  private:
      NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
  
-    // CoreIPC::MessageSender
-    virtual CoreIPC::Connection* messageSenderConnection() OVERRIDE;
+    // IPC::MessageSender
+    virtual IPC::Connection* messageSenderConnection() OVERRIDE;
      virtual uint64_t messageSenderDestinationID() OVERRIDE { return m_identifier; }
  
      void continueDidReceiveResponse();
diff --git a/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.h b/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.h

index 49d0c0f..bfa31e2 100644 (file)
--- a/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.h
+++ b/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.h
@@ -37,7 +37,7 @@ namespace WebKit {
  class NetworkConnectionToWebProcess;
  class NetworkResourceLoader;
  
-class DiskCacheMonitor : public CoreIPC::MessageSender {
+class DiskCacheMonitor : public IPC::MessageSender {
  public:
      static void monitorFileBackingStoreCreation(CFCachedURLResponseRef, NetworkResourceLoader*);
  
@@ -46,8 +46,8 @@ public:
  private:
      DiskCacheMonitor(CFCachedURLResponseRef, NetworkResourceLoader*);
  
-    // CoreIPC::MessageSender
-    virtual CoreIPC::Connection* messageSenderConnection() OVERRIDE;
+    // IPC::MessageSender
+    virtual IPC::Connection* messageSenderConnection() OVERRIDE;
      virtual uint64_t messageSenderDestinationID() OVERRIDE;
  
      RefPtr<NetworkConnectionToWebProcess> m_connectionToWebProcess;
diff --git a/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.mm b/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.mm

index 67b277c..fb1eaa0 100644 (file)
--- a/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.mm
+++ b/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.mm
@@ -94,7 +94,7 @@ DiskCacheMonitor::DiskCacheMonitor(CFCachedURLResponseRef cachedResponse, Networ
      _CFCachedURLResponseSetBecameFileBackedCallBackBlock(cachedResponse, block, dispatch_get_main_queue());
  }
  
-CoreIPC::Connection* DiskCacheMonitor::messageSenderConnection()
+IPC::Connection* DiskCacheMonitor::messageSenderConnection()
  {
      return m_connectionToWebProcess->connection();
  }
diff --git a/Source/WebKit2/Platform/IPC/ArgumentCoder.h b/Source/WebKit2/Platform/IPC/ArgumentCoder.h

index 4b0d692..2af313c 100644 (file)
--- a/Source/WebKit2/Platform/IPC/ArgumentCoder.h
+++ b/Source/WebKit2/Platform/IPC/ArgumentCoder.h
@@ -26,7 +26,7 @@
  #ifndef ArgumentCoder_h
  #define ArgumentCoder_h
  
-namespace CoreIPC {
+namespace IPC {
  
  class ArgumentDecoder;
  class ArgumentEncoder;
diff --git a/Source/WebKit2/Platform/IPC/ArgumentCoders.cpp b/Source/WebKit2/Platform/IPC/ArgumentCoders.cpp

index bd79604..5ca0641 100644 (file)
--- a/Source/WebKit2/Platform/IPC/ArgumentCoders.cpp
+++ b/Source/WebKit2/Platform/IPC/ArgumentCoders.cpp
@@ -30,7 +30,7 @@
  #include <wtf/text/CString.h>
  #include <wtf/text/WTFString.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  void ArgumentCoder<AtomicString>::encode(ArgumentEncoder& encoder, const AtomicString& atomicString)
  {
@@ -147,4 +147,4 @@ bool ArgumentCoder<String>::decode(ArgumentDecoder& decoder, String& result)
      return decodeStringText<UChar>(decoder, length, result);
  }
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/ArgumentCoders.h b/Source/WebKit2/Platform/IPC/ArgumentCoders.h

index 804f2dc..c04b7a9 100644 (file)
--- a/Source/WebKit2/Platform/IPC/ArgumentCoders.h
+++ b/Source/WebKit2/Platform/IPC/ArgumentCoders.h
@@ -33,7 +33,7 @@
  #include <wtf/HashMap.h>
  #include <wtf/Vector.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  // An argument coder works on POD types
  template<typename T> struct SimpleArgumentCoder {
@@ -208,6 +208,6 @@ template<> struct ArgumentCoder<String> {
      static bool decode(ArgumentDecoder&, String&);
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // ArgumentCoders_h
diff --git a/Source/WebKit2/Platform/IPC/ArgumentDecoder.cpp b/Source/WebKit2/Platform/IPC/ArgumentDecoder.cpp

index b80d5e5..6d396be 100644 (file)
--- a/Source/WebKit2/Platform/IPC/ArgumentDecoder.cpp
+++ b/Source/WebKit2/Platform/IPC/ArgumentDecoder.cpp
@@ -29,7 +29,7 @@
  #include "DataReference.h"
  #include <stdio.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  ArgumentDecoder::ArgumentDecoder(const uint8_t* buffer, size_t bufferSize)
  {
@@ -224,4 +224,4 @@ bool ArgumentDecoder::removeAttachment(Attachment& attachment)
      return true;
  }
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/ArgumentDecoder.h b/Source/WebKit2/Platform/IPC/ArgumentDecoder.h

index c7c8854..b35ce3f 100644 (file)
--- a/Source/WebKit2/Platform/IPC/ArgumentDecoder.h
+++ b/Source/WebKit2/Platform/IPC/ArgumentDecoder.h
@@ -30,7 +30,7 @@
  #include "Attachment.h"
  #include <wtf/Vector.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  class DataReference;
      
@@ -106,6 +106,6 @@ private:
      Vector<Attachment> m_attachments;
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // ArgumentDecoder_h
diff --git a/Source/WebKit2/Platform/IPC/ArgumentEncoder.cpp b/Source/WebKit2/Platform/IPC/ArgumentEncoder.cpp

index b636508..ee85630 100644 (file)
--- a/Source/WebKit2/Platform/IPC/ArgumentEncoder.cpp
+++ b/Source/WebKit2/Platform/IPC/ArgumentEncoder.cpp
@@ -34,7 +34,7 @@
  #include <sys/mman.h>
  #endif
  
-namespace CoreIPC {
+namespace IPC {
  
  static inline void* allocBuffer(size_t size)
  {
@@ -195,4 +195,4 @@ Vector<Attachment> ArgumentEncoder::releaseAttachments()
      return newList;
  }
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/ArgumentEncoder.h b/Source/WebKit2/Platform/IPC/ArgumentEncoder.h

index 047c35d..4242915 100644 (file)
--- a/Source/WebKit2/Platform/IPC/ArgumentEncoder.h
+++ b/Source/WebKit2/Platform/IPC/ArgumentEncoder.h
@@ -30,7 +30,7 @@
  #include "Attachment.h"
  #include <wtf/Vector.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  class ArgumentEncoder;
  class DataReference;
@@ -91,6 +91,6 @@ private:
      Vector<Attachment> m_attachments;
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // ArgumentEncoder_h
diff --git a/Source/WebKit2/Platform/IPC/Arguments.h b/Source/WebKit2/Platform/IPC/Arguments.h

index ac0f071..7921e1a 100644 (file)
--- a/Source/WebKit2/Platform/IPC/Arguments.h
+++ b/Source/WebKit2/Platform/IPC/Arguments.h
@@ -29,7 +29,7 @@
  #include "ArgumentDecoder.h"
  #include "ArgumentEncoder.h"
  
-namespace CoreIPC {
+namespace IPC {
  
  template<size_t index, typename... Elements>
  struct TupleCoder {
@@ -386,6 +386,6 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
      T10 argument10;
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // Arguments_h
diff --git a/Source/WebKit2/Platform/IPC/Attachment.cpp b/Source/WebKit2/Platform/IPC/Attachment.cpp

index 0e367a7..9367b1a 100644 (file)
--- a/Source/WebKit2/Platform/IPC/Attachment.cpp
+++ b/Source/WebKit2/Platform/IPC/Attachment.cpp
@@ -29,7 +29,7 @@
  #include "ArgumentDecoder.h"
  #include "ArgumentEncoder.h"
  
-namespace CoreIPC {
+namespace IPC {
  
  Attachment::Attachment()
      : m_type(Uninitialized)
@@ -62,4 +62,4 @@ bool Attachment::decode(ArgumentDecoder& decoder, Attachment& attachment)
      return true;
  }
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/Attachment.h b/Source/WebKit2/Platform/IPC/Attachment.h

index 7115f0b..b0f1dce 100644 (file)
--- a/Source/WebKit2/Platform/IPC/Attachment.h
+++ b/Source/WebKit2/Platform/IPC/Attachment.h
@@ -31,7 +31,7 @@
  #include <mach/mach_traps.h>
  #endif
  
-namespace CoreIPC {
+namespace IPC {
  
  class ArgumentDecoder;
  class ArgumentEncoder;
@@ -90,6 +90,6 @@ private:
  #endif
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // Attachment_h
diff --git a/Source/WebKit2/Platform/IPC/Connection.cpp b/Source/WebKit2/Platform/IPC/Connection.cpp

index 821182d..6cbecbb 100644 (file)
--- a/Source/WebKit2/Platform/IPC/Connection.cpp
+++ b/Source/WebKit2/Platform/IPC/Connection.cpp
@@ -33,7 +33,7 @@
  #include <wtf/text/WTFString.h>
  #include <wtf/threads/BinarySemaphore.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  class Connection::SyncMessageState : public ThreadSafeRefCounted<Connection::SyncMessageState> {
  public:
@@ -218,7 +218,7 @@ Connection::Connection(Identifier identifier, bool isServer, Client* client, Run
      , m_shouldExitOnSyncMessageSendFailure(false)
      , m_didCloseOnConnectionWorkQueueCallback(0)
      , m_isConnected(false)
-    , m_connectionQueue(WorkQueue::create("com.apple.CoreIPC.ReceiveQueue"))
+    , m_connectionQueue(WorkQueue::create("com.apple.IPC.ReceiveQueue"))
      , m_clientRunLoop(clientRunLoop)
      , m_inSendSyncCount(0)
      , m_inDispatchMessageCount(0)
@@ -837,4 +837,4 @@ void Connection::wakeUpRunLoop()
      m_clientRunLoop->wakeUp();
  }
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/Connection.h b/Source/WebKit2/Platform/IPC/Connection.h

index cb9be54..1b71650 100644 (file)
--- a/Source/WebKit2/Platform/IPC/Connection.h
+++ b/Source/WebKit2/Platform/IPC/Connection.h
@@ -54,7 +54,7 @@ namespace WTF {
  class RunLoop;
  }
  
-namespace CoreIPC {
+namespace IPC {
  
  enum MessageSendFlags {
      // Whether this message should be dispatched when waiting for a sync reply.
@@ -351,6 +351,6 @@ template<typename T> bool Connection::waitForAndDispatchImmediately(uint64_t des
      return true;
  }
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // Connection_h
diff --git a/Source/WebKit2/Platform/IPC/HandleMessage.h b/Source/WebKit2/Platform/IPC/HandleMessage.h

index f0c5c18..88468b1 100644 (file)
--- a/Source/WebKit2/Platform/IPC/HandleMessage.h
+++ b/Source/WebKit2/Platform/IPC/HandleMessage.h
@@ -5,7 +5,7 @@
  #include "MessageDecoder.h"
  #include "MessageEncoder.h"
  
-namespace CoreIPC {
+namespace IPC {
  
  // Dispatch functions with no reply arguments.
  template<typename C, typename MF>
@@ -445,6 +445,6 @@ void handleMessageDelayed(Connection* connection, MessageDecoder& decoder, std::
      callMemberFunction(std::move(arguments), delayedReply.release(), object, function);
  }
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // HandleMessage_h
diff --git a/Source/WebKit2/Platform/IPC/MessageDecoder.cpp b/Source/WebKit2/Platform/IPC/MessageDecoder.cpp

index 0dfe237..5dfda21 100644 (file)
--- a/Source/WebKit2/Platform/IPC/MessageDecoder.cpp
+++ b/Source/WebKit2/Platform/IPC/MessageDecoder.cpp
@@ -35,7 +35,7 @@
  #include "ImportanceAssertion.h"
  #endif
  
-namespace CoreIPC {
+namespace IPC {
  
  MessageDecoder::~MessageDecoder()
  {
@@ -73,4 +73,4 @@ void MessageDecoder::setImportanceAssertion(std::unique_ptr<ImportanceAssertion>
  }
  #endif
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/MessageDecoder.h b/Source/WebKit2/Platform/IPC/MessageDecoder.h

index e3d42f3..0b09baa 100644 (file)
--- a/Source/WebKit2/Platform/IPC/MessageDecoder.h
+++ b/Source/WebKit2/Platform/IPC/MessageDecoder.h
@@ -29,7 +29,7 @@
  #include "ArgumentDecoder.h"
  #include "StringReference.h"
  
-namespace CoreIPC {
+namespace IPC {
  
  class DataReference;
  class ImportanceAssertion;
@@ -62,6 +62,6 @@ private:
  #endif
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // MessageDecoder_h
diff --git a/Source/WebKit2/Platform/IPC/MessageEncoder.cpp b/Source/WebKit2/Platform/IPC/MessageEncoder.cpp

index 11d7f6e..d2e4efe 100644 (file)
--- a/Source/WebKit2/Platform/IPC/MessageEncoder.cpp
+++ b/Source/WebKit2/Platform/IPC/MessageEncoder.cpp
@@ -30,7 +30,7 @@
  #include "MessageFlags.h"
  #include "StringReference.h"
  
-namespace CoreIPC {
+namespace IPC {
  
  static uint8_t defaultMessageFlags = 0;
  
@@ -64,4 +64,4 @@ void MessageEncoder::setShouldDispatchMessageWhenWaitingForSyncReply(bool should
          *buffer() &= ~DispatchMessageWhenWaitingForSyncReply;
  }
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/MessageEncoder.h b/Source/WebKit2/Platform/IPC/MessageEncoder.h

index 5753df4..524e5e1 100644 (file)
--- a/Source/WebKit2/Platform/IPC/MessageEncoder.h
+++ b/Source/WebKit2/Platform/IPC/MessageEncoder.h
@@ -29,7 +29,7 @@
  #include "ArgumentEncoder.h"
  #include <wtf/Forward.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  class StringReference;
  
@@ -42,6 +42,6 @@ public:
      void setShouldDispatchMessageWhenWaitingForSyncReply(bool);
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // MessageEncoder_h
diff --git a/Source/WebKit2/Platform/IPC/MessageFlags.h b/Source/WebKit2/Platform/IPC/MessageFlags.h

index e3e980f..187ca98 100644 (file)
--- a/Source/WebKit2/Platform/IPC/MessageFlags.h
+++ b/Source/WebKit2/Platform/IPC/MessageFlags.h
@@ -26,13 +26,13 @@
  #ifndef MessageFlags_h
  #define MessageFlags_h
  
-namespace CoreIPC {
+namespace IPC {
  
  enum MessageFlags {
      SyncMessage = 1 << 0,
      DispatchMessageWhenWaitingForSyncReply = 1 << 1,
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // MessageFlags_h
diff --git a/Source/WebKit2/Platform/IPC/MessageReceiver.h b/Source/WebKit2/Platform/IPC/MessageReceiver.h

index b8d29b0..331b7c3 100644 (file)
--- a/Source/WebKit2/Platform/IPC/MessageReceiver.h
+++ b/Source/WebKit2/Platform/IPC/MessageReceiver.h
@@ -29,7 +29,7 @@
  #include <wtf/Assertions.h>
  #include <wtf/OwnPtr.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  class MessageDecoder;
  class MessageEncoder;
@@ -46,6 +46,6 @@ public:
      }
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // MessageReceiver_h
diff --git a/Source/WebKit2/Platform/IPC/MessageReceiverMap.cpp b/Source/WebKit2/Platform/IPC/MessageReceiverMap.cpp

index 0f03e22..da6d7c5 100644 (file)
--- a/Source/WebKit2/Platform/IPC/MessageReceiverMap.cpp
+++ b/Source/WebKit2/Platform/IPC/MessageReceiverMap.cpp
@@ -29,7 +29,7 @@
  #include "MessageDecoder.h"
  #include "MessageReceiver.h"
  
-namespace CoreIPC {
+namespace IPC {
  
  MessageReceiverMap::MessageReceiverMap()
  {
@@ -108,4 +108,4 @@ bool MessageReceiverMap::dispatchSyncMessage(Connection* connection, MessageDeco
      return false;
  }
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/MessageReceiverMap.h b/Source/WebKit2/Platform/IPC/MessageReceiverMap.h

index 4e62181..b00d364 100644 (file)
--- a/Source/WebKit2/Platform/IPC/MessageReceiverMap.h
+++ b/Source/WebKit2/Platform/IPC/MessageReceiverMap.h
@@ -30,7 +30,7 @@
  #include <wtf/HashMap.h>
  #include <wtf/text/CString.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  class Connection;
  class MessageDecoder;
diff --git a/Source/WebKit2/Platform/IPC/mac/ConnectionMac.cpp b/Source/WebKit2/Platform/IPC/mac/ConnectionMac.cpp

index d33ac41..392e0f8 100644 (file)
--- a/Source/WebKit2/Platform/IPC/mac/ConnectionMac.cpp
+++ b/Source/WebKit2/Platform/IPC/mac/ConnectionMac.cpp
@@ -35,7 +35,7 @@
  #include <wtf/RunLoop.h>
  #include <xpc/xpc.h>
  
-namespace CoreIPC {
+namespace IPC {
  
  static const size_t inlineMessageMaxSize = 4096;
  
@@ -491,4 +491,4 @@ void Connection::setShouldCloseConnectionOnMachExceptions()
          ASSERT_NOT_REACHED();
  }
  
-} // namespace CoreIPC
+} // namespace IPC
diff --git a/Source/WebKit2/Platform/IPC/mac/ImportanceAssertion.h b/Source/WebKit2/Platform/IPC/mac/ImportanceAssertion.h

index f373232..cbe3ad5 100644 (file)
--- a/Source/WebKit2/Platform/IPC/mac/ImportanceAssertion.h
+++ b/Source/WebKit2/Platform/IPC/mac/ImportanceAssertion.h
@@ -35,7 +35,7 @@
  extern "C" int proc_importance_assertion_begin_with_msg(mach_msg_header_t*, mach_msg_trailer_t*, uint64_t*);
  extern "C" int proc_importance_assertion_complete(uint64_t assertion_handle);
  
-namespace CoreIPC {
+namespace IPC {
  
  class ImportanceAssertion {
      WTF_MAKE_NONCOPYABLE(ImportanceAssertion);
diff --git a/Source/WebKit2/Platform/IPC/mac/MachPort.h b/Source/WebKit2/Platform/IPC/mac/MachPort.h

index 47aceb7..663ffcc 100644 (file)
--- a/Source/WebKit2/Platform/IPC/mac/MachPort.h
+++ b/Source/WebKit2/Platform/IPC/mac/MachPort.h
@@ -30,7 +30,7 @@
  #include "ArgumentEncoder.h"
  #include "Attachment.h"
  
-namespace CoreIPC {
+namespace IPC {
  
  class MachPort {
  public:
@@ -70,6 +70,6 @@ private:
      mach_msg_type_name_t m_disposition;
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  #endif // MachPort_h
diff --git a/Source/WebKit2/Platform/SharedMemory.h b/Source/WebKit2/Platform/SharedMemory.h

index 3f430dd..efa5f00 100644 (file)
--- a/Source/WebKit2/Platform/SharedMemory.h
+++ b/Source/WebKit2/Platform/SharedMemory.h
@@ -35,7 +35,7 @@
  #include <wtf/text/WTFString.h>
  #endif
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -57,11 +57,11 @@ public:
  
          bool isNull() const;
  
-        void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
+        void encode(IPC::ArgumentEncoder&) const;
+        static bool decode(IPC::ArgumentDecoder&, Handle&);
  
  #if USE(UNIX_DOMAIN_SOCKETS)
-        CoreIPC::Attachment releaseToAttachment() const;
+        IPC::Attachment releaseToAttachment() const;
          void adoptFromAttachment(int fileDescriptor, size_t);
  #endif
      private:
diff --git a/Source/WebKit2/Platform/mac/SharedMemoryMac.cpp b/Source/WebKit2/Platform/mac/SharedMemoryMac.cpp

index c7b52d9..46a43f3 100644 (file)
--- a/Source/WebKit2/Platform/mac/SharedMemoryMac.cpp
+++ b/Source/WebKit2/Platform/mac/SharedMemoryMac.cpp
@@ -55,14 +55,14 @@ bool SharedMemory::Handle::isNull() const
      return !m_port;
  }
  
-void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
+void SharedMemory::Handle::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << static_cast<uint64_t>(m_size);
-    encoder << CoreIPC::MachPort(m_port, MACH_MSG_TYPE_MOVE_SEND);
+    encoder << IPC::MachPort(m_port, MACH_MSG_TYPE_MOVE_SEND);
      m_port = MACH_PORT_NULL;
  }
  
-bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
+bool SharedMemory::Handle::decode(IPC::ArgumentDecoder& decoder, Handle& handle)
  {
      ASSERT(!handle.m_port);
      ASSERT(!handle.m_size);
@@ -71,7 +71,7 @@ bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& han
      if (!decoder.decode(size))
          return false;
  
-    CoreIPC::MachPort machPort;
+    IPC::MachPort machPort;
      if (!decoder.decode(machPort))
          return false;
      
diff --git a/Source/WebKit2/PluginProcess/PluginControllerProxy.cpp b/Source/WebKit2/PluginProcess/PluginControllerProxy.cpp

index d7346f7..277b089 100644 (file)
--- a/Source/WebKit2/PluginProcess/PluginControllerProxy.cpp
+++ b/Source/WebKit2/PluginProcess/PluginControllerProxy.cpp
@@ -437,7 +437,7 @@ void PluginControllerProxy::streamDidReceiveResponse(uint64_t streamID, const St
      m_plugin->streamDidReceiveResponse(streamID, URL(ParsedURLString, responseURLString), streamLength, lastModifiedTime, mimeType, headers, String());
  }
  
-void PluginControllerProxy::streamDidReceiveData(uint64_t streamID, const CoreIPC::DataReference& data)
+void PluginControllerProxy::streamDidReceiveData(uint64_t streamID, const IPC::DataReference& data)
  {
      m_plugin->streamDidReceiveData(streamID, reinterpret_cast<const char*>(data.data()), data.size());
  }
@@ -460,7 +460,7 @@ void PluginControllerProxy::manualStreamDidReceiveResponse(const String& respons
      m_plugin->manualStreamDidReceiveResponse(URL(ParsedURLString, responseURLString), streamLength, lastModifiedTime, mimeType, headers, String());
  }
  
-void PluginControllerProxy::manualStreamDidReceiveData(const CoreIPC::DataReference& data)
+void PluginControllerProxy::manualStreamDidReceiveData(const IPC::DataReference& data)
  {
      if (m_pluginCanceledManualStreamLoad)
          return;
diff --git a/Source/WebKit2/PluginProcess/PluginControllerProxy.h b/Source/WebKit2/PluginProcess/PluginControllerProxy.h

index e87c7a7..d769971 100644 (file)
--- a/Source/WebKit2/PluginProcess/PluginControllerProxy.h
+++ b/Source/WebKit2/PluginProcess/PluginControllerProxy.h
@@ -38,7 +38,7 @@
  #include <wtf/Noncopyable.h>
  #include <wtf/RunLoop.h>
  
-namespace CoreIPC {
+namespace IPC {
      class DataReference;
  }
  
@@ -61,8 +61,8 @@ public:
      bool initialize(const PluginCreationParameters&);
      void destroy();
  
-    void didReceivePluginControllerProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
-    void didReceiveSyncPluginControllerProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&);
+    void didReceivePluginControllerProxyMessage(IPC::Connection*, IPC::MessageDecoder&);
+    void didReceiveSyncPluginControllerProxyMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
  
      bool wantsWheelEvents() const;
  
@@ -124,11 +124,11 @@ private:
      void geometryDidChange(const WebCore::IntSize& pluginSize, const WebCore::IntRect& clipRect, const WebCore::AffineTransform& pluginToRootViewTransform, float contentsScaleFactor, const ShareableBitmap::Handle& backingStoreHandle);
      void didEvaluateJavaScript(uint64_t requestID, const String& result);
      void streamDidReceiveResponse(uint64_t streamID, const String& responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers);
-    void streamDidReceiveData(uint64_t streamID, const CoreIPC::DataReference& data);
+    void streamDidReceiveData(uint64_t streamID, const IPC::DataReference& data);
      void streamDidFinishLoading(uint64_t streamID);
      void streamDidFail(uint64_t streamID, bool wasCancelled);
      void manualStreamDidReceiveResponse(const String& responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers);
-    void manualStreamDidReceiveData(const CoreIPC::DataReference& data);
+    void manualStreamDidReceiveData(const IPC::DataReference& data);
      void manualStreamDidFinishLoading();
      void manualStreamDidFail(bool wasCancelled);
      void handleMouseEvent(const WebMouseEvent&, PassRefPtr<Messages::PluginControllerProxy::HandleMouseEvent::DelayedReply>);
diff --git a/Source/WebKit2/PluginProcess/PluginControllerProxy.messages.in b/Source/WebKit2/PluginProcess/PluginControllerProxy.messages.in

index dd763e0..6fa85f6 100644 (file)
--- a/Source/WebKit2/PluginProcess/PluginControllerProxy.messages.in
+++ b/Source/WebKit2/PluginProcess/PluginControllerProxy.messages.in
@@ -39,7 +39,7 @@ messages -> PluginControllerProxy LegacyReceiver {
      StreamDidReceiveResponse(uint64_t streamID, String responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, String mimeType, String headers)
  
      # Sent when the plug-in receives data for a stream.
-    StreamDidReceiveData(uint64_t streamID, CoreIPC::DataReference data)
+    StreamDidReceiveData(uint64_t streamID, IPC::DataReference data)
  
      # Sent when a plug-in stream has finishes loading.
      StreamDidFinishLoading(uint64_t streamID)
@@ -51,7 +51,7 @@ messages -> PluginControllerProxy LegacyReceiver {
      ManualStreamDidReceiveResponse(String responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, String mimeType, String headers)
  
      # Sent when the plug-in receives data for the manual stream.
-    ManualStreamDidReceiveData(CoreIPC::DataReference data)
+    ManualStreamDidReceiveData(IPC::DataReference data)
  
      # Sent when the plug-in manual stream has finishes loading.
      ManualStreamDidFinishLoading()
diff --git a/Source/WebKit2/PluginProcess/PluginCreationParameters.cpp b/Source/WebKit2/PluginProcess/PluginCreationParameters.cpp

index 105fff0..3d2492f 100644 (file)
--- a/Source/WebKit2/PluginProcess/PluginCreationParameters.cpp
+++ b/Source/WebKit2/PluginProcess/PluginCreationParameters.cpp
@@ -45,7 +45,7 @@ PluginCreationParameters::PluginCreationParameters()
  {
  }
  
-void PluginCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder) const
+void PluginCreationParameters::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << pluginInstanceID;
      encoder << windowNPObjectID;
@@ -61,7 +61,7 @@ void PluginCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder) const
  #endif
  }
  
-bool PluginCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, PluginCreationParameters& result)
+bool PluginCreationParameters::decode(IPC::ArgumentDecoder& decoder, PluginCreationParameters& result)
  {
      if (!decoder.decode(result.pluginInstanceID) || !result.pluginInstanceID)
          return false;
diff --git a/Source/WebKit2/PluginProcess/PluginCreationParameters.h b/Source/WebKit2/PluginProcess/PluginCreationParameters.h

index 301ea48..389f755 100644 (file)
--- a/Source/WebKit2/PluginProcess/PluginCreationParameters.h
+++ b/Source/WebKit2/PluginProcess/PluginCreationParameters.h
@@ -30,7 +30,7 @@
  
  #include "Plugin.h"
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -40,8 +40,8 @@ namespace WebKit {
  struct PluginCreationParameters {
      PluginCreationParameters();
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, PluginCreationParameters&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, PluginCreationParameters&);
  
      // The unique ID of this plug-in instance.
      uint64_t pluginInstanceID;
diff --git a/Source/WebKit2/PluginProcess/PluginProcess.cpp b/Source/WebKit2/PluginProcess/PluginProcess.cpp

index aafcdaa..37bcd78 100644 (file)
--- a/Source/WebKit2/PluginProcess/PluginProcess.cpp
+++ b/Source/WebKit2/PluginProcess/PluginProcess.cpp
@@ -121,19 +121,19 @@ bool PluginProcess::shouldTerminate()
      return m_webProcessConnections.isEmpty();
  }
  
-void PluginProcess::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
+void PluginProcess::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
  {
      didReceivePluginProcessMessage(connection, decoder);
  }
  
-void PluginProcess::didClose(CoreIPC::Connection*)
+void PluginProcess::didClose(IPC::Connection*)
  {
      // The UI process has crashed, just go ahead and quit.
      // FIXME: If the plug-in is spinning in the main loop, we'll never get this message.
      stopRunLoop();
  }
  
-void PluginProcess::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference, CoreIPC::StringReference)
+void PluginProcess::didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference, IPC::StringReference)
  {
  }
  
@@ -158,18 +158,18 @@ void PluginProcess::createWebProcessConnection()
      mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &listeningPort);
  
      // Create a listening connection.
-    RefPtr<WebProcessConnection> connection = WebProcessConnection::create(CoreIPC::Connection::Identifier(listeningPort));
+    RefPtr<WebProcessConnection> connection = WebProcessConnection::create(IPC::Connection::Identifier(listeningPort));
      m_webProcessConnections.append(connection.release());
  
-    CoreIPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
+    IPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
      parentProcessConnection()->send(Messages::PluginProcessProxy::DidCreateWebProcessConnection(clientPort, m_supportsAsynchronousPluginInitialization), 0);
  #elif USE(UNIX_DOMAIN_SOCKETS)
-    CoreIPC::Connection::SocketPair socketPair = CoreIPC::Connection::createPlatformConnection();
+    IPC::Connection::SocketPair socketPair = IPC::Connection::createPlatformConnection();
  
      RefPtr<WebProcessConnection> connection = WebProcessConnection::create(socketPair.server);
      m_webProcessConnections.append(connection.release());
  
-    CoreIPC::Attachment clientSocket(socketPair.client);
+    IPC::Attachment clientSocket(socketPair.client);
      parentProcessConnection()->send(Messages::PluginProcessProxy::DidCreateWebProcessConnection(clientSocket, m_supportsAsynchronousPluginInitialization), 0);
  #else
      notImplemented();
diff --git a/Source/WebKit2/PluginProcess/PluginProcess.h b/Source/WebKit2/PluginProcess/PluginProcess.h

index 4bfa2b9..dadd3f4 100644 (file)
--- a/Source/WebKit2/PluginProcess/PluginProcess.h
+++ b/Source/WebKit2/PluginProcess/PluginProcess.h
@@ -80,13 +80,13 @@ private:
      virtual void stopRunLoop() OVERRIDE;
  #endif
  
-    // CoreIPC::Connection::Client
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
-    virtual void didClose(CoreIPC::Connection*) OVERRIDE;
-    virtual void didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference messageReceiverName, CoreIPC::StringReference messageName) OVERRIDE;
+    // IPC::Connection::Client
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) OVERRIDE;
+    virtual void didClose(IPC::Connection*) OVERRIDE;
+    virtual void didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference messageReceiverName, IPC::StringReference messageName) OVERRIDE;
  
      // Message handlers.
-    void didReceivePluginProcessMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
+    void didReceivePluginProcessMessage(IPC::Connection*, IPC::MessageDecoder&);
      void initializePluginProcess(const PluginProcessCreationParameters&);
      void createWebProcessConnection();
      void getSitesWithData(uint64_t callbackID);
diff --git a/Source/WebKit2/PluginProcess/WebProcessConnection.cpp b/Source/WebKit2/PluginProcess/WebProcessConnection.cpp

index 3a4d15a..5011089 100644 (file)
--- a/Source/WebKit2/PluginProcess/WebProcessConnection.cpp
+++ b/Source/WebKit2/PluginProcess/WebProcessConnection.cpp
@@ -46,7 +46,7 @@ using namespace WebCore;
  
  namespace WebKit {
  
-PassRefPtr<WebProcessConnection> WebProcessConnection::create(CoreIPC::Connection::Identifier connectionIdentifier)
+PassRefPtr<WebProcessConnection> WebProcessConnection::create(IPC::Connection::Identifier connectionIdentifier)
  {
      return adoptRef(new WebProcessConnection(connectionIdentifier));
  }
@@ -58,9 +58,9 @@ WebProcessConnection::~WebProcessConnection()
      ASSERT(!m_connection);
  }
      
-WebProcessConnection::WebProcessConnection(CoreIPC::Connection::Identifier connectionIdentifier)
+WebProcessConnection::WebProcessConnection(IPC::Connection::Identifier connectionIdentifier)
  {
-    m_connection = CoreIPC::Connection::createServerConnection(connectionIdentifier, this, RunLoop::main());
+    m_connection = IPC::Connection::createServerConnection(connectionIdentifier, this, RunLoop::main());
      m_npRemoteObjectMap = NPRemoteObjectMap::create(m_connection.get());
  
      m_connection->setOnlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage(true);
@@ -110,14 +110,14 @@ void WebProcessConnection::removePluginControllerProxy(PluginControllerProxy* pl
  
  void WebProcessConnection::setGlobalException(const String& exceptionString)
  {
-    CoreIPC::Connection* connection = ConnectionStack::shared().current();
+    IPC::Connection* connection = ConnectionStack::shared().current();
      if (!connection)
          return;
  
      connection->sendSync(Messages::PluginProcessConnection::SetException(exceptionString), Messages::PluginProcessConnection::SetException::Reply(), 0);
  }
  
-void WebProcessConnection::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
+void WebProcessConnection::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
  {
      ConnectionStack::CurrentConnectionPusher currentConnection(ConnectionStack::shared(), connection);
  
@@ -139,7 +139,7 @@ void WebProcessConnection::didReceiveMessage(CoreIPC::Connection* connection, Co
      pluginControllerProxy->didReceivePluginControllerProxyMessage(connection, decoder);
  }
  
-void WebProcessConnection::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)
+void WebProcessConnection::didReceiveSyncMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
  {
      // Force all timers to run at full speed when processing a synchronous message
      ActivityAssertion activityAssertion(PluginProcess::shared());
@@ -166,7 +166,7 @@ void WebProcessConnection::didReceiveSyncMessage(CoreIPC::Connection* connection
      pluginControllerProxy->didReceiveSyncPluginControllerProxyMessage(connection, decoder, replyEncoder);
  }
  
-void WebProcessConnection::didClose(CoreIPC::Connection*)
+void WebProcessConnection::didClose(IPC::Connection*)
  {
      // The web process crashed. Destroy all the plug-in controllers. Destroying the last plug-in controller
      // will cause the web process connection itself to be destroyed.
@@ -198,7 +198,7 @@ void WebProcessConnection::destroyPlugin(uint64_t pluginInstanceID, bool asynchr
      destroyPluginControllerProxy(pluginControllerProxy);
  }
  
-void WebProcessConnection::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference, CoreIPC::StringReference)
+void WebProcessConnection::didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference, IPC::StringReference)
  {
      // FIXME: Implement.
  }
diff --git a/Source/WebKit2/PluginProcess/WebProcessConnection.h b/Source/WebKit2/PluginProcess/WebProcessConnection.h

index 4d1c47c..79269e6 100644 (file)
--- a/Source/WebKit2/PluginProcess/WebProcessConnection.h
+++ b/Source/WebKit2/PluginProcess/WebProcessConnection.h
@@ -42,12 +42,12 @@ struct PluginCreationParameters;
      
  // A connection from a plug-in process to a web process.
  
-class WebProcessConnection : public RefCounted<WebProcessConnection>, CoreIPC::Connection::Client {
+class WebProcessConnection : public RefCounted<WebProcessConnection>, IPC::Connection::Client {
  public:
-    static PassRefPtr<WebProcessConnection> create(CoreIPC::Connection::Identifier);
+    static PassRefPtr<WebProcessConnection> create(IPC::Connection::Identifier);
      virtual ~WebProcessConnection();
  
-    CoreIPC::Connection* connection() const { return m_connection.get(); }
+    IPC::Connection* connection() const { return m_connection.get(); }
      NPRemoteObjectMap* npRemoteObjectMap() const { return m_npRemoteObjectMap.get(); }
  
      void removePluginControllerProxy(PluginControllerProxy*, Plugin*);
@@ -55,28 +55,28 @@ public:
      static void setGlobalException(const String&);
  
  private:
-    WebProcessConnection(CoreIPC::Connection::Identifier);
+    WebProcessConnection(IPC::Connection::Identifier);
  
      void addPluginControllerProxy(std::unique_ptr<PluginControllerProxy>);
  
      void destroyPluginControllerProxy(PluginControllerProxy*);
  
-    // CoreIPC::Connection::Client
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
-    virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&) OVERRIDE;
-    virtual void didClose(CoreIPC::Connection*);
-    virtual void didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::StringReference messageReceiverName, CoreIPC::StringReference messageName);
+    // IPC::Connection::Client
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) OVERRIDE;
+    virtual void didReceiveSyncMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&) OVERRIDE;
+    virtual void didClose(IPC::Connection*);
+    virtual void didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference messageReceiverName, IPC::StringReference messageName);
  
      // Message handlers.
-    void didReceiveWebProcessConnectionMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
-    void didReceiveSyncWebProcessConnectionMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&);
+    void didReceiveWebProcessConnectionMessage(IPC::Connection*, IPC::MessageDecoder&);
+    void didReceiveSyncWebProcessConnectionMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
      void createPlugin(const PluginCreationParameters&, PassRefPtr<Messages::WebProcessConnection::CreatePlugin::DelayedReply>);
      void createPluginAsynchronously(const PluginCreationParameters&);
      void destroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete);
      
      void createPluginInternal(const PluginCreationParameters&, bool& result, bool& wantsWheelEvents, uint32_t& remoteLayerClientID);
  
-    RefPtr<CoreIPC::Connection> m_connection;
+    RefPtr<IPC::Connection> m_connection;
  
      HashMap<uint64_t, std::unique_ptr<PluginControllerProxy>> m_pluginControllers;
      RefPtr<NPRemoteObjectMap> m_npRemoteObjectMap;
diff --git a/Source/WebKit2/PluginProcess/mac/PluginControllerProxyMac.mm b/Source/WebKit2/PluginProcess/mac/PluginControllerProxyMac.mm

index fabf86e..bbe1195 100644 (file)
--- a/Source/WebKit2/PluginProcess/mac/PluginControllerProxyMac.mm
+++ b/Source/WebKit2/PluginProcess/mac/PluginControllerProxyMac.mm
@@ -47,7 +47,7 @@ void PluginControllerProxy::pluginFocusOrWindowFocusChanged(bool pluginHasFocusA
  
  void PluginControllerProxy::setComplexTextInputState(PluginComplexTextInputState pluginComplexTextInputState)
  {
-    m_connection->connection()->send(Messages::PluginProxy::SetComplexTextInputState(pluginComplexTextInputState), m_pluginInstanceID, CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply);
+    m_connection->connection()->send(Messages::PluginProxy::SetComplexTextInputState(pluginComplexTextInputState), m_pluginInstanceID, IPC::DispatchMessageEvenWhenWaitingForSyncReply);
  }
  
  mach_port_t PluginControllerProxy::compositingRenderServerPort()
diff --git a/Source/WebKit2/Scripts/webkit2/messages.py b/Source/WebKit2/Scripts/webkit2/messages.py

index 64f19ac..84e9b7f 100644 (file)
--- a/Source/WebKit2/Scripts/webkit2/messages.py
+++ b/Source/WebKit2/Scripts/webkit2/messages.py
@@ -94,7 +94,7 @@ def reply_parameter_type(type):
  
  
  def arguments_type_old(parameters, parameter_type_function):
-    arguments_type = 'CoreIPC::Arguments%d' % len(parameters)
+    arguments_type = 'IPC::Arguments%d' % len(parameters)
      if len(parameters):
          arguments_type = '%s<%s>' % (arguments_type, ', '.join(parameter_type_function(parameter.type) for parameter in parameters))
      return arguments_type
@@ -130,22 +130,22 @@ def message_to_struct_declaration(message):
      result.append('public:\n')
      result.append('    typedef %s DecodeType;\n' % decode_type(message))
      result.append('\n')
-    result.append('    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }\n')
-    result.append('    static CoreIPC::StringReference name() { return CoreIPC::StringReference("%s"); }\n' % message.name)
+    result.append('    static IPC::StringReference receiverName() { return messageReceiverName(); }\n')
+    result.append('    static IPC::StringReference name() { return IPC::StringReference("%s"); }\n' % message.name)
      result.append('    static const bool isSync = %s;\n' % ('false', 'true')[message.reply_parameters != None])
      result.append('\n')
      if message.reply_parameters != None:
          if message.has_attribute(DELAYED_ATTRIBUTE):
              send_parameters = [(function_parameter_type(x.type), x.name) for x in message.reply_parameters]
              result.append('    struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {\n')
-            result.append('        DelayedReply(PassRefPtr<CoreIPC::Connection>, std::unique_ptr<CoreIPC::MessageEncoder>);\n')
+            result.append('        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::MessageEncoder>);\n')
              result.append('        ~DelayedReply();\n')
              result.append('\n')
              result.append('        bool send(%s);\n' % ', '.join([' '.join(x) for x in send_parameters]))
              result.append('\n')
              result.append('    private:\n')
-            result.append('        RefPtr<CoreIPC::Connection> m_connection;\n')
-            result.append('        std::unique_ptr<CoreIPC::MessageEncoder> m_encoder;\n')
+            result.append('        RefPtr<IPC::Connection> m_connection;\n')
+            result.append('        std::unique_ptr<IPC::MessageEncoder> m_encoder;\n')
              result.append('    };\n\n')
  
          result.append('    typedef %s Reply;\n' % reply_type(message))
@@ -251,7 +251,7 @@ def forward_declarations_and_headers(receiver):
      for message in receiver.messages:
          if message.reply_parameters != None and message.has_attribute(DELAYED_ATTRIBUTE):
              headers.add('<wtf/ThreadSafeRefCounted.h>')
-            types_by_namespace['CoreIPC'].update(['Connection'])
+            types_by_namespace['IPC'].update(['Connection'])
  
      for parameter in receiver.iterparameters():
          type = parameter.type
@@ -305,9 +305,9 @@ def generate_messages_header(file):
  
      result.append('namespace Messages {\nnamespace %s {\n' % receiver.name)
      result.append('\n')
-    result.append('static inline CoreIPC::StringReference messageReceiverName()\n')
+    result.append('static inline IPC::StringReference messageReceiverName()\n')
      result.append('{\n')
-    result.append('    return CoreIPC::StringReference("%s");\n' % receiver.name)
+    result.append('    return IPC::StringReference("%s");\n' % receiver.name)
      result.append('}\n')
      result.append('\n')
      result.append('\n'.join([message_to_struct_declaration(x) for x in receiver.messages]))
@@ -340,7 +340,7 @@ def async_message_statement(receiver, message):
  
      result = []
      result.append('    if (decoder.messageName() == Messages::%s::%s::name()) {\n' % (receiver.name, message.name))
-    result.append('        CoreIPC::%s<Messages::%s::%s>(%s);\n' % (dispatch_function, receiver.name, message.name, ', '.join(dispatch_function_args)))
+    result.append('        IPC::%s<Messages::%s::%s>(%s);\n' % (dispatch_function, receiver.name, message.name, ', '.join(dispatch_function_args)))
      result.append('        return;\n')
      result.append('    }\n')
      return surround_in_condition(''.join(result), message.condition)
@@ -357,7 +357,7 @@ def sync_message_statement(receiver, message):
  
      result = []
      result.append('    if (decoder.messageName() == Messages::%s::%s::name()) {\n' % (receiver.name, message.name))
-    result.append('        CoreIPC::%s<Messages::%s::%s>(%sdecoder, %sreplyEncoder, this, &%s);\n' % (dispatch_function, receiver.name, message.name, 'connection, ' if wants_connection else '', '' if message.has_attribute(DELAYED_ATTRIBUTE) else '*', handler_function(receiver, message)))
+    result.append('        IPC::%s<Messages::%s::%s>(%sdecoder, %sreplyEncoder, this, &%s);\n' % (dispatch_function, receiver.name, message.name, 'connection, ' if wants_connection else '', '' if message.has_attribute(DELAYED_ATTRIBUTE) else '*', handler_function(receiver, message)))
      result.append('        return;\n')
      result.append('    }\n')
      return surround_in_condition(''.join(result), message.condition)
@@ -460,7 +460,7 @@ def headers_for_type(type):
          if len(split) < 2:
              continue
  
-        if split[0] == 'WebKit' or split[0] == 'CoreIPC':
+        if split[0] == 'WebKit' or split[0] == 'IPC':
              headers.append('"%s.h"' % split[1])
          else:
              headers.append('<%s/%s.h>' % tuple(split))
@@ -551,7 +551,7 @@ def generate_message_handler(file):
              if message.condition:
                  result.append('#if %s\n\n' % message.condition)
  
-            result.append('%s::DelayedReply::DelayedReply(PassRefPtr<CoreIPC::Connection> connection, std::unique_ptr<CoreIPC::MessageEncoder> encoder)\n' % message.name)
+            result.append('%s::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::MessageEncoder> encoder)\n' % message.name)
              result.append('    : m_connection(connection)\n')
              result.append('    , m_encoder(std::move(encoder))\n')
              result.append('{\n')
@@ -589,9 +589,9 @@ def generate_message_handler(file):
  
      if async_messages:
          if receiver.has_attribute(LEGACY_RECEIVER_ATTRIBUTE):
-            result.append('void %s::didReceive%sMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder& decoder)\n' % (receiver.name, receiver.name))
+            result.append('void %s::didReceive%sMessage(IPC::Connection*, IPC::MessageDecoder& decoder)\n' % (receiver.name, receiver.name))
          else:
-            result.append('void %s::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)\n' % (receiver.name))
+            result.append('void %s::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)\n' % (receiver.name))
  
          result.append('{\n')
          result += [async_message_statement(receiver, message) for message in async_messages]
@@ -603,9 +603,9 @@ def generate_message_handler(file):
      if sync_messages:
          result.append('\n')
          if receiver.has_attribute(LEGACY_RECEIVER_ATTRIBUTE):
-            result.append('void %s::didReceiveSync%sMessage(CoreIPC::Connection*%s, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)\n' % (receiver.name, receiver.name, ' connection' if sync_delayed_messages else ''))
+            result.append('void %s::didReceiveSync%sMessage(IPC::Connection*%s, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)\n' % (receiver.name, receiver.name, ' connection' if sync_delayed_messages else ''))
          else:
-            result.append('void %s::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)\n' % (receiver.name))
+            result.append('void %s::didReceiveSyncMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)\n' % (receiver.name))
          result.append('{\n')
          result += [sync_message_statement(receiver, message) for message in sync_messages]
          if not receiver.has_attribute(LEGACY_RECEIVER_ATTRIBUTE):
diff --git a/Source/WebKit2/Scripts/webkit2/messages_unittest.py b/Source/WebKit2/Scripts/webkit2/messages_unittest.py

index ed58633..97f7e3e 100644 (file)
--- a/Source/WebKit2/Scripts/webkit2/messages_unittest.py
+++ b/Source/WebKit2/Scripts/webkit2/messages_unittest.py
@@ -73,7 +73,7 @@ messages -> WebPage LegacyReceiver {
      CreatePlugin(uint64_t pluginInstanceID, WebKit::Plugin::Parameters parameters) -> (bool result)
      RunJavaScriptAlert(uint64_t frameID, String message) -> ()
      GetPlugins(bool refresh) -> (Vector<WebCore::PluginInfo> plugins)
-    GetPluginProcessConnection(String pluginPath) -> (CoreIPC::Connection::Handle connectionHandle) Delayed
+    GetPluginProcessConnection(String pluginPath) -> (IPC::Connection::Handle connectionHandle) Delayed
  
      TestMultipleAttributes() -> () WantsConnection Delayed
  
@@ -82,7 +82,7 @@ messages -> WebPage LegacyReceiver {
      TemplateTest(HashMap<String, std::pair<String, uint64_t>> a)
  
  #if PLATFORM(MAC)
-    DidCreateWebProcessConnection(CoreIPC::MachPort connectionIdentifier)
+    DidCreateWebProcessConnection(IPC::MachPort connectionIdentifier)
  #endif
  
  #if PLATFORM(MAC)
@@ -91,11 +91,11 @@ messages -> WebPage LegacyReceiver {
  #endif
  
  #if ENABLE(DEPRECATED_FEATURE)
-    DeprecatedOperation(CoreIPC::DummyType dummy)
+    DeprecatedOperation(IPC::DummyType dummy)
  #endif
  
  #if ENABLE(EXPERIMENTAL_FEATURE)
-    ExperimentalOperation(CoreIPC::DummyType dummy)
+    ExperimentalOperation(IPC::DummyType dummy)
  #endif
  }
  
@@ -215,7 +215,7 @@ _expected_results = {
                  ('String', 'pluginPath'),
              ),
              'reply_parameters': (
-                ('CoreIPC::Connection::Handle', 'connectionHandle'),
+                ('IPC::Connection::Handle', 'connectionHandle'),
              ),
              'conditions': (None),
          },
@@ -246,7 +246,7 @@ _expected_results = {
          {
              'name': 'DidCreateWebProcessConnection',
              'parameters': (
-                ('CoreIPC::MachPort', 'connectionIdentifier'),
+                ('IPC::MachPort', 'connectionIdentifier'),
              ),
              'conditions': ('PLATFORM(MAC)'),
          },
@@ -263,14 +263,14 @@ _expected_results = {
          {
              'name': 'DeprecatedOperation',
              'parameters': (
-                ('CoreIPC::DummyType', 'dummy'),
+                ('IPC::DummyType', 'dummy'),
              ),
              'conditions': ('ENABLE(DEPRECATED_FEATURE)'),
          },
          {
              'name': 'ExperimentalOperation',
              'parameters': (
-                ('CoreIPC::DummyType', 'dummy'),
+                ('IPC::DummyType', 'dummy'),
              ),
              'conditions': ('ENABLE(EXPERIMENTAL_FEATURE)'),
          }
@@ -355,7 +355,7 @@ _expected_header = """/*
  #include <wtf/Vector.h>
  #include <wtf/text/WTFString.h>
  
-namespace CoreIPC {
+namespace IPC {
      class Connection;
      class DummyType;
      class MachPort;
@@ -373,17 +373,17 @@ namespace WebKit {
  namespace Messages {
  namespace WebPage {
  
-static inline CoreIPC::StringReference messageReceiverName()
+static inline IPC::StringReference messageReceiverName()
  {
-    return CoreIPC::StringReference("WebPage");
+    return IPC::StringReference("WebPage");
  }
  
  class LoadURL {
  public:
      typedef std::tuple<String> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("LoadURL"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("LoadURL"); }
      static const bool isSync = false;
  
      explicit LoadURL(const String& url)
@@ -405,8 +405,8 @@ class LoadSomething {
  public:
      typedef std::tuple<String> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("LoadSomething"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("LoadSomething"); }
      static const bool isSync = false;
  
      explicit LoadSomething(const String& url)
@@ -429,8 +429,8 @@ class TouchEvent {
  public:
      typedef std::tuple<WebKit::WebTouchEvent> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("TouchEvent"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("TouchEvent"); }
      static const bool isSync = false;
  
      explicit TouchEvent(const WebKit::WebTouchEvent& event)
@@ -453,8 +453,8 @@ class AddEvent {
  public:
      typedef std::tuple<WebKit::WebTouchEvent> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("AddEvent"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("AddEvent"); }
      static const bool isSync = false;
  
      explicit AddEvent(const WebKit::WebTouchEvent& event)
@@ -477,8 +477,8 @@ class LoadSomethingElse {
  public:
      typedef std::tuple<String> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("LoadSomethingElse"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("LoadSomethingElse"); }
      static const bool isSync = false;
  
      explicit LoadSomethingElse(const String& url)
@@ -500,8 +500,8 @@ class DidReceivePolicyDecision {
  public:
      typedef std::tuple<uint64_t, uint64_t, uint32_t> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("DidReceivePolicyDecision"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("DidReceivePolicyDecision"); }
      static const bool isSync = false;
  
      DidReceivePolicyDecision(uint64_t frameID, uint64_t listenerID, uint32_t policyAction)
@@ -522,8 +522,8 @@ class Close {
  public:
      typedef std::tuple<> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("Close"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("Close"); }
      static const bool isSync = false;
  
      const std::tuple<> arguments() const
@@ -539,8 +539,8 @@ class PreferencesDidChange {
  public:
      typedef std::tuple<WebKit::WebPreferencesStore> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("PreferencesDidChange"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("PreferencesDidChange"); }
      static const bool isSync = false;
  
      explicit PreferencesDidChange(const WebKit::WebPreferencesStore& store)
@@ -561,8 +561,8 @@ class SendDoubleAndFloat {
  public:
      typedef std::tuple<double, float> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("SendDoubleAndFloat"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("SendDoubleAndFloat"); }
      static const bool isSync = false;
  
      SendDoubleAndFloat(double d, float f)
@@ -583,8 +583,8 @@ class SendInts {
  public:
      typedef std::tuple<Vector<uint64_t>, Vector<Vector<uint64_t>>> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("SendInts"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("SendInts"); }
      static const bool isSync = false;
  
      SendInts(const Vector<uint64_t>& ints, const Vector<Vector<uint64_t>>& intVectors)
@@ -605,11 +605,11 @@ class CreatePlugin {
  public:
      typedef std::tuple<uint64_t, WebKit::Plugin::Parameters> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("CreatePlugin"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("CreatePlugin"); }
      static const bool isSync = true;
  
-    typedef CoreIPC::Arguments1<bool&> Reply;
+    typedef IPC::Arguments1<bool&> Reply;
      CreatePlugin(uint64_t pluginInstanceID, const WebKit::Plugin::Parameters& parameters)
          : m_arguments(pluginInstanceID, parameters)
      {
@@ -628,11 +628,11 @@ class RunJavaScriptAlert {
  public:
      typedef std::tuple<uint64_t, String> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("RunJavaScriptAlert"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("RunJavaScriptAlert"); }
      static const bool isSync = true;
  
-    typedef CoreIPC::Arguments0 Reply;
+    typedef IPC::Arguments0 Reply;
      RunJavaScriptAlert(uint64_t frameID, const String& message)
          : m_arguments(frameID, message)
      {
@@ -651,11 +651,11 @@ class GetPlugins {
  public:
      typedef std::tuple<bool> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("GetPlugins"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("GetPlugins"); }
      static const bool isSync = true;
  
-    typedef CoreIPC::Arguments1<Vector<WebCore::PluginInfo>&> Reply;
+    typedef IPC::Arguments1<Vector<WebCore::PluginInfo>&> Reply;
      explicit GetPlugins(bool refresh)
          : m_arguments(refresh)
      {
@@ -674,22 +674,22 @@ class GetPluginProcessConnection {
  public:
      typedef std::tuple<String> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("GetPluginProcessConnection"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("GetPluginProcessConnection"); }
      static const bool isSync = true;
  
      struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {
-        DelayedReply(PassRefPtr<CoreIPC::Connection>, std::unique_ptr<CoreIPC::MessageEncoder>);
+        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::MessageEncoder>);
          ~DelayedReply();
  
-        bool send(const CoreIPC::Connection::Handle& connectionHandle);
+        bool send(const IPC::Connection::Handle& connectionHandle);
  
      private:
-        RefPtr<CoreIPC::Connection> m_connection;
-        std::unique_ptr<CoreIPC::MessageEncoder> m_encoder;
+        RefPtr<IPC::Connection> m_connection;
+        std::unique_ptr<IPC::MessageEncoder> m_encoder;
      };
  
-    typedef CoreIPC::Arguments1<CoreIPC::Connection::Handle&> Reply;
+    typedef IPC::Arguments1<IPC::Connection::Handle&> Reply;
      explicit GetPluginProcessConnection(const String& pluginPath)
          : m_arguments(pluginPath)
      {
@@ -708,22 +708,22 @@ class TestMultipleAttributes {
  public:
      typedef std::tuple<> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("TestMultipleAttributes"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("TestMultipleAttributes"); }
      static const bool isSync = true;
  
      struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {
-        DelayedReply(PassRefPtr<CoreIPC::Connection>, std::unique_ptr<CoreIPC::MessageEncoder>);
+        DelayedReply(PassRefPtr<IPC::Connection>, std::unique_ptr<IPC::MessageEncoder>);
          ~DelayedReply();
  
          bool send();
  
      private:
-        RefPtr<CoreIPC::Connection> m_connection;
-        std::unique_ptr<CoreIPC::MessageEncoder> m_encoder;
+        RefPtr<IPC::Connection> m_connection;
+        std::unique_ptr<IPC::MessageEncoder> m_encoder;
      };
  
-    typedef CoreIPC::Arguments0 Reply;
+    typedef IPC::Arguments0 Reply;
      const std::tuple<> arguments() const
      {
          return m_arguments;
@@ -737,8 +737,8 @@ class TestParameterAttributes {
  public:
      typedef std::tuple<uint64_t, double, double> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("TestParameterAttributes"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("TestParameterAttributes"); }
      static const bool isSync = false;
  
      TestParameterAttributes(uint64_t foo, double bar, double baz)
@@ -759,8 +759,8 @@ class TemplateTest {
  public:
      typedef std::tuple<HashMap<String, std::pair<String, uint64_t>>> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("TemplateTest"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("TemplateTest"); }
      static const bool isSync = false;
  
      explicit TemplateTest(const HashMap<String, std::pair<String, uint64_t>>& a)
@@ -780,24 +780,24 @@ private:
  #if PLATFORM(MAC)
  class DidCreateWebProcessConnection {
  public:
-    typedef std::tuple<CoreIPC::MachPort> DecodeType;
+    typedef std::tuple<IPC::MachPort> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("DidCreateWebProcessConnection"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("DidCreateWebProcessConnection"); }
      static const bool isSync = false;
  
-    explicit DidCreateWebProcessConnection(const CoreIPC::MachPort& connectionIdentifier)
+    explicit DidCreateWebProcessConnection(const IPC::MachPort& connectionIdentifier)
          : m_arguments(connectionIdentifier)
      {
      }
  
-    const std::tuple<const CoreIPC::MachPort&> arguments() const
+    const std::tuple<const IPC::MachPort&> arguments() const
      {
          return m_arguments;
      }
  
  private:
-    std::tuple<const CoreIPC::MachPort&> m_arguments;
+    std::tuple<const IPC::MachPort&> m_arguments;
  };
  #endif
  
@@ -806,11 +806,11 @@ class InterpretKeyEvent {
  public:
      typedef std::tuple<uint32_t> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("InterpretKeyEvent"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("InterpretKeyEvent"); }
      static const bool isSync = true;
  
-    typedef CoreIPC::Arguments1<Vector<WebCore::KeypressCommand>&> Reply;
+    typedef IPC::Arguments1<Vector<WebCore::KeypressCommand>&> Reply;
      explicit InterpretKeyEvent(uint32_t type)
          : m_arguments(type)
      {
@@ -829,48 +829,48 @@ private:
  #if ENABLE(DEPRECATED_FEATURE)
  class DeprecatedOperation {
  public:
-    typedef std::tuple<CoreIPC::DummyType> DecodeType;
+    typedef std::tuple<IPC::DummyType> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("DeprecatedOperation"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("DeprecatedOperation"); }
      static const bool isSync = false;
  
-    explicit DeprecatedOperation(const CoreIPC::DummyType& dummy)
+    explicit DeprecatedOperation(const IPC::DummyType& dummy)
          : m_arguments(dummy)
      {
      }
  
-    const std::tuple<const CoreIPC::DummyType&> arguments() const
+    const std::tuple<const IPC::DummyType&> arguments() const
      {
          return m_arguments;
      }
  
  private:
-    std::tuple<const CoreIPC::DummyType&> m_arguments;
+    std::tuple<const IPC::DummyType&> m_arguments;
  };
  #endif
  
  #if ENABLE(EXPERIMENTAL_FEATURE)
  class ExperimentalOperation {
  public:
-    typedef std::tuple<CoreIPC::DummyType> DecodeType;
+    typedef std::tuple<IPC::DummyType> DecodeType;
  
-    static CoreIPC::StringReference receiverName() { return messageReceiverName(); }
-    static CoreIPC::StringReference name() { return CoreIPC::StringReference("ExperimentalOperation"); }
+    static IPC::StringReference receiverName() { return messageReceiverName(); }
+    static IPC::StringReference name() { return IPC::StringReference("ExperimentalOperation"); }
      static const bool isSync = false;
  
-    explicit ExperimentalOperation(const CoreIPC::DummyType& dummy)
+    explicit ExperimentalOperation(const IPC::DummyType& dummy)
          : m_arguments(dummy)
      {
      }
  
-    const std::tuple<const CoreIPC::DummyType&> arguments() const
+    const std::tuple<const IPC::DummyType&> arguments() const
      {
          return m_arguments;
      }
  
  private:
-    std::tuple<const CoreIPC::DummyType&> m_arguments;
+    std::tuple<const IPC::DummyType&> m_arguments;
  };
  #endif
  
@@ -942,7 +942,7 @@ namespace Messages {
  
  namespace WebPage {
  
-GetPluginProcessConnection::DelayedReply::DelayedReply(PassRefPtr<CoreIPC::Connection> connection, std::unique_ptr<CoreIPC::MessageEncoder> encoder)
+GetPluginProcessConnection::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::MessageEncoder> encoder)
      : m_connection(connection)
      , m_encoder(std::move(encoder))
  {
@@ -953,7 +953,7 @@ GetPluginProcessConnection::DelayedReply::~DelayedReply()
      ASSERT(!m_connection);
  }
  
-bool GetPluginProcessConnection::DelayedReply::send(const CoreIPC::Connection::Handle& connectionHandle)
+bool GetPluginProcessConnection::DelayedReply::send(const IPC::Connection::Handle& connectionHandle)
  {
      ASSERT(m_encoder);
      *m_encoder << connectionHandle;
@@ -962,7 +962,7 @@ bool GetPluginProcessConnection::DelayedReply::send(const CoreIPC::Connection::H
      return result;
  }
  
-TestMultipleAttributes::DelayedReply::DelayedReply(PassRefPtr<CoreIPC::Connection> connection, std::unique_ptr<CoreIPC::MessageEncoder> encoder)
+TestMultipleAttributes::DelayedReply::DelayedReply(PassRefPtr<IPC::Connection> connection, std::unique_ptr<IPC::MessageEncoder> encoder)
      : m_connection(connection)
      , m_encoder(std::move(encoder))
  {
@@ -987,110 +987,110 @@ bool TestMultipleAttributes::DelayedReply::send()
  
  namespace WebKit {
  
-void WebPage::didReceiveWebPageMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder& decoder)
+void WebPage::didReceiveWebPageMessage(IPC::Connection*, IPC::MessageDecoder& decoder)
  {
      if (decoder.messageName() == Messages::WebPage::LoadURL::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::LoadURL>(decoder, this, &WebPage::loadURL);
+        IPC::handleMessage<Messages::WebPage::LoadURL>(decoder, this, &WebPage::loadURL);
          return;
      }
  #if ENABLE(TOUCH_EVENTS)
      if (decoder.messageName() == Messages::WebPage::LoadSomething::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::LoadSomething>(decoder, this, &WebPage::loadSomething);
+        IPC::handleMessage<Messages::WebPage::LoadSomething>(decoder, this, &WebPage::loadSomething);
          return;
      }
  #endif
  #if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION || SOME_OTHER_MESSAGE_CONDITION))
      if (decoder.messageName() == Messages::WebPage::TouchEvent::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::TouchEvent>(decoder, this, &WebPage::touchEvent);
+        IPC::handleMessage<Messages::WebPage::TouchEvent>(decoder, this, &WebPage::touchEvent);
          return;
      }
  #endif
  #if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION && SOME_OTHER_MESSAGE_CONDITION))
      if (decoder.messageName() == Messages::WebPage::AddEvent::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::AddEvent>(decoder, this, &WebPage::addEvent);
+        IPC::handleMessage<Messages::WebPage::AddEvent>(decoder, this, &WebPage::addEvent);
          return;
      }
  #endif
  #if ENABLE(TOUCH_EVENTS)
      if (decoder.messageName() == Messages::WebPage::LoadSomethingElse::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::LoadSomethingElse>(decoder, this, &WebPage::loadSomethingElse);
+        IPC::handleMessage<Messages::WebPage::LoadSomethingElse>(decoder, this, &WebPage::loadSomethingElse);
          return;
      }
  #endif
      if (decoder.messageName() == Messages::WebPage::DidReceivePolicyDecision::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::DidReceivePolicyDecision>(decoder, this, &WebPage::didReceivePolicyDecision);
+        IPC::handleMessage<Messages::WebPage::DidReceivePolicyDecision>(decoder, this, &WebPage::didReceivePolicyDecision);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::Close::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::Close>(decoder, this, &WebPage::close);
+        IPC::handleMessage<Messages::WebPage::Close>(decoder, this, &WebPage::close);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::PreferencesDidChange::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::PreferencesDidChange>(decoder, this, &WebPage::preferencesDidChange);
+        IPC::handleMessage<Messages::WebPage::PreferencesDidChange>(decoder, this, &WebPage::preferencesDidChange);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::SendDoubleAndFloat::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::SendDoubleAndFloat>(decoder, this, &WebPage::sendDoubleAndFloat);
+        IPC::handleMessage<Messages::WebPage::SendDoubleAndFloat>(decoder, this, &WebPage::sendDoubleAndFloat);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::SendInts::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::SendInts>(decoder, this, &WebPage::sendInts);
+        IPC::handleMessage<Messages::WebPage::SendInts>(decoder, this, &WebPage::sendInts);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::TestParameterAttributes::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::TestParameterAttributes>(decoder, this, &WebPage::testParameterAttributes);
+        IPC::handleMessage<Messages::WebPage::TestParameterAttributes>(decoder, this, &WebPage::testParameterAttributes);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::TemplateTest::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::TemplateTest>(decoder, this, &WebPage::templateTest);
+        IPC::handleMessage<Messages::WebPage::TemplateTest>(decoder, this, &WebPage::templateTest);
          return;
      }
  #if PLATFORM(MAC)
      if (decoder.messageName() == Messages::WebPage::DidCreateWebProcessConnection::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::DidCreateWebProcessConnection>(decoder, this, &WebPage::didCreateWebProcessConnection);
+        IPC::handleMessage<Messages::WebPage::DidCreateWebProcessConnection>(decoder, this, &WebPage::didCreateWebProcessConnection);
          return;
      }
  #endif
  #if ENABLE(DEPRECATED_FEATURE)
      if (decoder.messageName() == Messages::WebPage::DeprecatedOperation::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::DeprecatedOperation>(decoder, this, &WebPage::deprecatedOperation);
+        IPC::handleMessage<Messages::WebPage::DeprecatedOperation>(decoder, this, &WebPage::deprecatedOperation);
          return;
      }
  #endif
  #if ENABLE(EXPERIMENTAL_FEATURE)
      if (decoder.messageName() == Messages::WebPage::ExperimentalOperation::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::ExperimentalOperation>(decoder, this, &WebPage::experimentalOperation);
+        IPC::handleMessage<Messages::WebPage::ExperimentalOperation>(decoder, this, &WebPage::experimentalOperation);
          return;
      }
  #endif
      ASSERT_NOT_REACHED();
  }
  
-void WebPage::didReceiveSyncWebPageMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)
+void WebPage::didReceiveSyncWebPageMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
  {
      if (decoder.messageName() == Messages::WebPage::CreatePlugin::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::CreatePlugin>(decoder, *replyEncoder, this, &WebPage::createPlugin);
+        IPC::handleMessage<Messages::WebPage::CreatePlugin>(decoder, *replyEncoder, this, &WebPage::createPlugin);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::RunJavaScriptAlert::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::RunJavaScriptAlert>(decoder, *replyEncoder, this, &WebPage::runJavaScriptAlert);
+        IPC::handleMessage<Messages::WebPage::RunJavaScriptAlert>(decoder, *replyEncoder, this, &WebPage::runJavaScriptAlert);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::GetPlugins::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::GetPlugins>(decoder, *replyEncoder, this, &WebPage::getPlugins);
+        IPC::handleMessage<Messages::WebPage::GetPlugins>(decoder, *replyEncoder, this, &WebPage::getPlugins);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::GetPluginProcessConnection::name()) {
-        CoreIPC::handleMessageDelayed<Messages::WebPage::GetPluginProcessConnection>(connection, decoder, replyEncoder, this, &WebPage::getPluginProcessConnection);
+        IPC::handleMessageDelayed<Messages::WebPage::GetPluginProcessConnection>(connection, decoder, replyEncoder, this, &WebPage::getPluginProcessConnection);
          return;
      }
      if (decoder.messageName() == Messages::WebPage::TestMultipleAttributes::name()) {
-        CoreIPC::handleMessageDelayed<Messages::WebPage::TestMultipleAttributes>(connection, decoder, replyEncoder, this, &WebPage::testMultipleAttributes);
+        IPC::handleMessageDelayed<Messages::WebPage::TestMultipleAttributes>(connection, decoder, replyEncoder, this, &WebPage::testMultipleAttributes);
          return;
      }
  #if PLATFORM(MAC)
      if (decoder.messageName() == Messages::WebPage::InterpretKeyEvent::name()) {
-        CoreIPC::handleMessage<Messages::WebPage::InterpretKeyEvent>(decoder, *replyEncoder, this, &WebPage::interpretKeyEvent);
+        IPC::handleMessage<Messages::WebPage::InterpretKeyEvent>(decoder, *replyEncoder, this, &WebPage::interpretKeyEvent);
          return;
      }
  #endif
diff --git a/Source/WebKit2/Shared/API/Cocoa/RemoteObjectRegistry.h b/Source/WebKit2/Shared/API/Cocoa/RemoteObjectRegistry.h

index 10d8f6f..09c2f05 100644 (file)
--- a/Source/WebKit2/Shared/API/Cocoa/RemoteObjectRegistry.h
+++ b/Source/WebKit2/Shared/API/Cocoa/RemoteObjectRegistry.h
@@ -38,7 +38,7 @@ namespace WebKit {
  
  class UserData;
  
-class RemoteObjectRegistry FINAL : public CoreIPC::MessageReceiver {
+class RemoteObjectRegistry FINAL : public IPC::MessageReceiver {
  public:
      RemoteObjectRegistry(WKRemoteObjectRegistry *, IPC::MessageSender&);
      ~RemoteObjectRegistry();
@@ -46,8 +46,8 @@ public:
      void sendInvocation(const UserData&);
  
  private:
-    // CoreIPC::MessageReceiver
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
+    // IPC::MessageReceiver
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) OVERRIDE;
  
      // Message handlers
      void invokeMethod(const UserData&);
diff --git a/Source/WebKit2/Shared/APIGeometry.cpp b/Source/WebKit2/Shared/APIGeometry.cpp

index 610b978..c59827b 100644 (file)
--- a/Source/WebKit2/Shared/APIGeometry.cpp
+++ b/Source/WebKit2/Shared/APIGeometry.cpp
@@ -31,13 +31,13 @@
  
  namespace API {
  
-void Point::encode(CoreIPC::ArgumentEncoder& encoder) const
+void Point::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_point.x;
      encoder << m_point.y;
  }
  
-bool Point::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
+bool Point::decode(IPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
  {
      WKPoint point;
      if (!decoder.decode(point.x))
@@ -50,13 +50,13 @@ bool Point::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& resul
  }
  
  
-void Size::encode(CoreIPC::ArgumentEncoder& encoder) const
+void Size::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_size.width;
      encoder << m_size.height;
  }
  
-bool Size::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
+bool Size::decode(IPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
  {
      WKSize size;
      if (!decoder.decode(size.width))
@@ -69,7 +69,7 @@ bool Size::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result
  }
  
  
-void Rect::encode(CoreIPC::ArgumentEncoder& encoder) const
+void Rect::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_rect.origin.x;
      encoder << m_rect.origin.y;
@@ -77,7 +77,7 @@ void Rect::encode(CoreIPC::ArgumentEncoder& encoder) const
      encoder << m_rect.size.height;
  }
  
-bool Rect::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
+bool Rect::decode(IPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
  {
      WKRect rect;
      if (!decoder.decode(rect.origin.x))
diff --git a/Source/WebKit2/Shared/APIGeometry.h b/Source/WebKit2/Shared/APIGeometry.h

index 907d704..2efcb47 100644 (file)
--- a/Source/WebKit2/Shared/APIGeometry.h
+++ b/Source/WebKit2/Shared/APIGeometry.h
@@ -31,7 +31,7 @@
  #include <WebCore/FloatRect.h>
  #include <wtf/PassRefPtr.h>
  
-namespace CoreIPC {
+namespace IPC {
  class ArgumentDecoder;
  class ArgumentEncoder;
  }
@@ -47,8 +47,8 @@ public:
  
      const WKSize& size() const { return m_size; }
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, RefPtr<API::Object>&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, RefPtr<API::Object>&);
  
  private:
      explicit Size(const WKSize& size)
@@ -68,8 +68,8 @@ public:
  
      const WKPoint& point() const { return m_point; }
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, RefPtr<API::Object>&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, RefPtr<API::Object>&);
  
  private:
      explicit Point(const WKPoint& point)
@@ -88,8 +88,8 @@ public:
  
      const WKRect& rect() const { return m_rect; }
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, RefPtr<API::Object>&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, RefPtr<API::Object>&);
  
  private:
      explicit Rect(const WKRect& rect)
diff --git a/Source/WebKit2/Shared/APINumber.h b/Source/WebKit2/Shared/APINumber.h

index 5c10100..02a4da9 100644 (file)
--- a/Source/WebKit2/Shared/APINumber.h
+++ b/Source/WebKit2/Shared/APINumber.h
@@ -43,12 +43,12 @@ public:
  
      NumberType value() const { return m_value; }
  
-    void encode(CoreIPC::ArgumentEncoder& encoder) const
+    void encode(IPC::ArgumentEncoder& encoder) const
      {
          encoder << m_value;
      }
  
-    static bool decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<Object>& result)
+    static bool decode(IPC::ArgumentDecoder& decoder, RefPtr<Object>& result)
      {
          NumberType value;
          if (!decoder.decode(value))
diff --git a/Source/WebKit2/Shared/Authentication/AuthenticationManager.h b/Source/WebKit2/Shared/Authentication/AuthenticationManager.h

index 4975986..e68e3fa 100644 (file)
--- a/Source/WebKit2/Shared/Authentication/AuthenticationManager.h
+++ b/Source/WebKit2/Shared/Authentication/AuthenticationManager.h
@@ -45,7 +45,7 @@ class ChildProcess;
  class Download;
  class WebFrame;
  
-class AuthenticationManager : public WebProcessSupplement, public NetworkProcessSupplement, public CoreIPC::MessageReceiver {
+class AuthenticationManager : public WebProcessSupplement, public NetworkProcessSupplement, public IPC::MessageReceiver {
      WTF_MAKE_NONCOPYABLE(AuthenticationManager);
  public:
      explicit AuthenticationManager(ChildProcess*);
@@ -66,8 +66,8 @@ public:
      uint64_t outstandingAuthenticationChallengeCount() const { return m_challenges.size(); }
  
  private:
-    // CoreIPC::MessageReceiver
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
+    // IPC::MessageReceiver
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) OVERRIDE;
  
      bool tryUseCertificateInfoForChallenge(const WebCore::AuthenticationChallenge&, const WebCore::CertificateInfo&);
  
diff --git a/Source/WebKit2/Shared/ChildProcess.cpp b/Source/WebKit2/Shared/ChildProcess.cpp

index 2c9f164..cafe471 100644 (file)
--- a/Source/WebKit2/Shared/ChildProcess.cpp
+++ b/Source/WebKit2/Shared/ChildProcess.cpp
@@ -55,7 +55,7 @@ NO_RETURN static void watchdogCallback()
      _exit(EXIT_FAILURE);
  }
  
-static void didCloseOnConnectionWorkQueue(CoreIPC::Connection*)
+static void didCloseOnConnectionWorkQueue(IPC::Connection*)
  {
      // If the connection has been closed and we haven't responded in the main thread for 10 seconds
      // the process will exit forcibly.
@@ -74,7 +74,7 @@ void ChildProcess::initialize(const ChildProcessInitializationParameters& parame
      SandboxInitializationParameters sandboxParameters;
      initializeSandbox(parameters, sandboxParameters);
      
-    m_connection = CoreIPC::Connection::createClientConnection(parameters.connectionIdentifier, this, RunLoop::main());
+    m_connection = IPC::Connection::createClientConnection(parameters.connectionIdentifier, this, RunLoop::main());
      m_connection->setDidCloseOnConnectionWorkQueueCallback(didCloseOnConnectionWorkQueue);
      initializeConnection(m_connection.get());
      m_connection->open();
@@ -88,21 +88,21 @@ void ChildProcess::initializeProcessName(const ChildProcessInitializationParamet
  {
  }
  
-void ChildProcess::initializeConnection(CoreIPC::Connection*)
+void ChildProcess::initializeConnection(IPC::Connection*)
  {
  }
  
-void ChildProcess::addMessageReceiver(CoreIPC::StringReference messageReceiverName, CoreIPC::MessageReceiver& messageReceiver)
+void ChildProcess::addMessageReceiver(IPC::StringReference messageReceiverName, IPC::MessageReceiver& messageReceiver)
  {
      m_messageReceiverMap.addMessageReceiver(messageReceiverName, messageReceiver);
  }
  
-void ChildProcess::addMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID, CoreIPC::MessageReceiver& messageReceiver)
+void ChildProcess::addMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID, IPC::MessageReceiver& messageReceiver)
  {
      m_messageReceiverMap.addMessageReceiver(messageReceiverName, destinationID, messageReceiver);
  }
  
-void ChildProcess::removeMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID)
+void ChildProcess::removeMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID)
  {
      m_messageReceiverMap.removeMessageReceiver(messageReceiverName, destinationID);
  }
@@ -129,7 +129,7 @@ void ChildProcess::enableTermination()
      m_terminationTimer.startOneShot(m_terminationTimeout);
  }
  
-CoreIPC::Connection* ChildProcess::messageSenderConnection()
+IPC::Connection* ChildProcess::messageSenderConnection()
  {
      return m_connection.get();
  }
diff --git a/Source/WebKit2/Shared/ChildProcess.h b/Source/WebKit2/Shared/ChildProcess.h

index 29850e1..7fc0f76 100644 (file)
--- a/Source/WebKit2/Shared/ChildProcess.h
+++ b/Source/WebKit2/Shared/ChildProcess.h
@@ -42,11 +42,11 @@ class SandboxInitializationParameters;
  struct ChildProcessInitializationParameters {
      String uiProcessName;
      String clientIdentifier;
-    CoreIPC::Connection::Identifier connectionIdentifier;
+    IPC::Connection::Identifier connectionIdentifier;
      HashMap<String, String> extraInitializationData;
  };
  
-class ChildProcess : protected CoreIPC::Connection::Client, public CoreIPC::MessageSender {
+class ChildProcess : protected IPC::Connection::Client, public IPC::MessageSender {
      WTF_MAKE_NONCOPYABLE(ChildProcess);
  
  public:
@@ -57,9 +57,9 @@ public:
      void disableTermination();
      void enableTermination();
  
-    void addMessageReceiver(CoreIPC::StringReference messageReceiverName, CoreIPC::MessageReceiver&);
-    void addMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID, CoreIPC::MessageReceiver&);
-    void removeMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID);
+    void addMessageReceiver(IPC::StringReference messageReceiverName, IPC::MessageReceiver&);
+    void addMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID, IPC::MessageReceiver&);
+    void removeMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID);
  
  #if PLATFORM(MAC)
      void setProcessSuppressionEnabled(bool);
@@ -73,9 +73,9 @@ public:
      void decrementActiveTaskCount() { }
  #endif
  
-    CoreIPC::Connection* parentProcessConnection() const { return m_connection.get(); }
+    IPC::Connection* parentProcessConnection() const { return m_connection.get(); }
  
-    CoreIPC::MessageReceiverMap& messageReceiverMap() { return m_messageReceiverMap; }
+    IPC::MessageReceiverMap& messageReceiverMap() { return m_messageReceiverMap; }
  
  protected:
      explicit ChildProcess();
@@ -86,7 +86,7 @@ protected:
      virtual void initializeProcess(const ChildProcessInitializationParameters&);
      virtual void initializeProcessName(const ChildProcessInitializationParameters&);
      virtual void initializeSandbox(const ChildProcessInitializationParameters&, SandboxInitializationParameters&);
-    virtual void initializeConnection(CoreIPC::Connection*);
+    virtual void initializeConnection(IPC::Connection*);
  
      virtual bool shouldTerminate() = 0;
      virtual void terminate();
@@ -98,8 +98,8 @@ protected:
  #endif
  
  private:
-    // CoreIPC::MessageSender
-    virtual CoreIPC::Connection* messageSenderConnection() OVERRIDE;
+    // IPC::MessageSender
+    virtual IPC::Connection* messageSenderConnection() OVERRIDE;
      virtual uint64_t messageSenderDestinationID() OVERRIDE;
  
      void terminationTimerFired();
@@ -116,8 +116,8 @@ private:
  
      RunLoop::Timer<ChildProcess> m_terminationTimer;
  
-    RefPtr<CoreIPC::Connection> m_connection;
-    CoreIPC::MessageReceiverMap m_messageReceiverMap;
+    RefPtr<IPC::Connection> m_connection;
+    IPC::MessageReceiverMap m_messageReceiverMap;
  
  #if PLATFORM(MAC)
      void suspensionHysteresisTimerFired();
diff --git a/Source/WebKit2/Shared/ChildProcessProxy.cpp b/Source/WebKit2/Shared/ChildProcessProxy.cpp

index 3be1e18..264d10b 100644 (file)
--- a/Source/WebKit2/Shared/ChildProcessProxy.cpp
+++ b/Source/WebKit2/Shared/ChildProcessProxy.cpp
@@ -45,7 +45,7 @@ ChildProcessProxy::~ChildProcessProxy()
      }
  }
  
-ChildProcessProxy* ChildProcessProxy::fromConnection(CoreIPC::Connection* connection)
+ChildProcessProxy* ChildProcessProxy::fromConnection(IPC::Connection* connection)
  {
      ASSERT(connection);
  
@@ -69,10 +69,9 @@ void ChildProcessProxy::terminate()
          m_processLauncher->terminateProcess();
  }
  
-bool ChildProcessProxy::sendMessage(std::unique_ptr<CoreIPC::MessageEncoder> encoder, unsigned messageSendFlags)
+bool ChildProcessProxy::sendMessage(std::unique_ptr<IPC::MessageEncoder> encoder, unsigned messageSendFlags)
  {
-    // If we're waiting for the web process to launch, we need to stash away the messages so we can send them once we have
-    // a CoreIPC connection.
+    // If we're waiting for the child process to launch, we need to stash away the messages so we can send them once we have a connection.
      if (isLaunching()) {
          m_pendingMessages.append(std::make_pair(std::move(encoder), messageSendFlags));
          return true;
@@ -85,27 +84,27 @@ bool ChildProcessProxy::sendMessage(std::unique_ptr<CoreIPC::MessageEncoder> enc
      return connection()->sendMessage(std::move(encoder), messageSendFlags);
  }
  
-void ChildProcessProxy::addMessageReceiver(CoreIPC::StringReference messageReceiverName, CoreIPC::MessageReceiver& messageReceiver)
+void ChildProcessProxy::addMessageReceiver(IPC::StringReference messageReceiverName, IPC::MessageReceiver& messageReceiver)
  {
      m_messageReceiverMap.addMessageReceiver(messageReceiverName, messageReceiver);
  }
  
-void ChildProcessProxy::addMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID, CoreIPC::MessageReceiver& messageReceiver)
+void ChildProcessProxy::addMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID, IPC::MessageReceiver& messageReceiver)
  {
      m_messageReceiverMap.addMessageReceiver(messageReceiverName, destinationID, messageReceiver);
  }
  
-void ChildProcessProxy::removeMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID)
+void ChildProcessProxy::removeMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID)
  {
      m_messageReceiverMap.removeMessageReceiver(messageReceiverName, destinationID);
  }
  
-bool ChildProcessProxy::dispatchMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
+bool ChildProcessProxy::dispatchMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
  {
      return m_messageReceiverMap.dispatchMessage(connection, decoder);
  }
  
-bool ChildProcessProxy::dispatchSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)
+bool ChildProcessProxy::dispatchSyncMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
  {
      return m_messageReceiverMap.dispatchSyncMessage(connection, decoder, replyEncoder);
  }
@@ -118,11 +117,11 @@ bool ChildProcessProxy::isLaunching() const
      return false;
  }
  
-void ChildProcessProxy::didFinishLaunching(ProcessLauncher*, CoreIPC::Connection::Identifier connectionIdentifier)
+void ChildProcessProxy::didFinishLaunching(ProcessLauncher*, IPC::Connection::Identifier connectionIdentifier)
  {
      ASSERT(!m_connection);
  
-    m_connection = CoreIPC::Connection::createServerConnection(connectionIdentifier, this, RunLoop::main());
+    m_connection = IPC::Connection::createServerConnection(connectionIdentifier, this, RunLoop::main());
  #if OS(DARWIN)
      m_connection->setShouldCloseConnectionOnMachExceptions();
  #endif
@@ -131,7 +130,7 @@ void ChildProcessProxy::didFinishLaunching(ProcessLauncher*, CoreIPC::Connection
      m_connection->open();
  
      for (size_t i = 0; i < m_pendingMessages.size(); ++i) {
-        std::unique_ptr<CoreIPC::MessageEncoder> message = std::move(m_pendingMessages[i].first);
+        std::unique_ptr<IPC::MessageEncoder> message = std::move(m_pendingMessages[i].first);
          unsigned messageSendFlags = m_pendingMessages[i].second;
          m_connection->sendMessage(std::move(message), messageSendFlags);
      }
@@ -159,11 +158,11 @@ void ChildProcessProxy::clearConnection()
      m_connection = nullptr;
  }
  
-void ChildProcessProxy::connectionWillOpen(CoreIPC::Connection*)
+void ChildProcessProxy::connectionWillOpen(IPC::Connection*)
  {
  }
  
-void ChildProcessProxy::connectionWillClose(CoreIPC::Connection*)
+void ChildProcessProxy::connectionWillClose(IPC::Connection*)
  {
  }
  
diff --git a/Source/WebKit2/Shared/ChildProcessProxy.h b/Source/WebKit2/Shared/ChildProcessProxy.h

index f66c03a..aefe0d9 100644 (file)
--- a/Source/WebKit2/Shared/ChildProcessProxy.h
+++ b/Source/WebKit2/Shared/ChildProcessProxy.h
@@ -34,7 +34,7 @@
  
  namespace WebKit {
  
-class ChildProcessProxy : ProcessLauncher::Client, public CoreIPC::Connection::Client, public ThreadSafeRefCounted<ChildProcessProxy> {
+class ChildProcessProxy : ProcessLauncher::Client, public IPC::Connection::Client, public ThreadSafeRefCounted<ChildProcessProxy> {
      WTF_MAKE_NONCOPYABLE(ChildProcessProxy);
  
  public:
@@ -42,7 +42,7 @@ public:
      virtual ~ChildProcessProxy();
  
      // FIXME: This function does an unchecked upcast, and it is only used in a deprecated code path. Would like to get rid of it.
-    static ChildProcessProxy* fromConnection(CoreIPC::Connection*);
+    static ChildProcessProxy* fromConnection(IPC::Connection*);
  
      void connect();
      void terminate();
@@ -50,15 +50,15 @@ public:
      template<typename T> bool send(T&& message, uint64_t destinationID, unsigned messageSendFlags = 0);
      template<typename T> bool sendSync(T&& message, typename T::Reply&&, uint64_t destinationID, double timeout = 1);
      
-    CoreIPC::Connection* connection() const
+    IPC::Connection* connection() const
      {
          ASSERT(m_connection);
          return m_connection.get();
      }
  
-    void addMessageReceiver(CoreIPC::StringReference messageReceiverName, CoreIPC::MessageReceiver&);
-    void addMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID, CoreIPC::MessageReceiver&);
-    void removeMessageReceiver(CoreIPC::StringReference messageReceiverName, uint64_t destinationID);
+    void addMessageReceiver(IPC::StringReference messageReceiverName, IPC::MessageReceiver&);
+    void addMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID, IPC::MessageReceiver&);
+    void removeMessageReceiver(IPC::StringReference messageReceiverName, uint64_t destinationID);
  
      bool isValid() const { return m_connection; }
      bool isLaunching() const;
@@ -66,27 +66,27 @@ public:
  
      PlatformProcessIdentifier processIdentifier() const { return m_processLauncher->processIdentifier(); }
  
-    bool sendMessage(std::unique_ptr<CoreIPC::MessageEncoder>, unsigned messageSendFlags);
+    bool sendMessage(std::unique_ptr<IPC::MessageEncoder>, unsigned messageSendFlags);
  
  protected:
      void clearConnection();
      void abortProcessLaunchIfNeeded();
  
      // ProcessLauncher::Client
-    virtual void didFinishLaunching(ProcessLauncher*, CoreIPC::Connection::Identifier) OVERRIDE;
+    virtual void didFinishLaunching(ProcessLauncher*, IPC::Connection::Identifier) OVERRIDE;
  
-    bool dispatchMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
-    bool dispatchSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&);
+    bool dispatchMessage(IPC::Connection*, IPC::MessageDecoder&);
+    bool dispatchSyncMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
  
  private:
      virtual void getLaunchOptions(ProcessLauncher::LaunchOptions&) = 0;
-    virtual void connectionWillOpen(CoreIPC::Connection*);
-    virtual void connectionWillClose(CoreIPC::Connection*);
+    virtual void connectionWillOpen(IPC::Connection*);
+    virtual void connectionWillClose(IPC::Connection*);
  
-    Vector<std::pair<std::unique_ptr<CoreIPC::MessageEncoder>, unsigned>> m_pendingMessages;
+    Vector<std::pair<std::unique_ptr<IPC::MessageEncoder>, unsigned>> m_pendingMessages;
      RefPtr<ProcessLauncher> m_processLauncher;
-    RefPtr<CoreIPC::Connection> m_connection;
-    CoreIPC::MessageReceiverMap m_messageReceiverMap;
+    RefPtr<IPC::Connection> m_connection;
+    IPC::MessageReceiverMap m_messageReceiverMap;
  };
  
  template<typename T>
@@ -94,7 +94,7 @@ bool ChildProcessProxy::send(T&& message, uint64_t destinationID, unsigned messa
  {
      COMPILE_ASSERT(!T::isSync, AsyncMessageExpected);
  
-    auto encoder = std::make_unique<CoreIPC::MessageEncoder>(T::receiverName(), T::name(), destinationID);
+    auto encoder = std::make_unique<IPC::MessageEncoder>(T::receiverName(), T::name(), destinationID);
      encoder->encode(message.arguments());
  
      return sendMessage(std::move(encoder), messageSendFlags);
diff --git a/Source/WebKit2/Shared/ChildProcessSupplement.h b/Source/WebKit2/Shared/ChildProcessSupplement.h

index 9a83405..dfbefba 100644 (file)
--- a/Source/WebKit2/Shared/ChildProcessSupplement.h
+++ b/Source/WebKit2/Shared/ChildProcessSupplement.h
@@ -26,9 +26,9 @@
  #ifndef ChildProcessSupplement_h
  #define ChildProcessSupplement_h
  
-namespace CoreIPC {
+namespace IPC {
  class Connection;
-} // namespace CoreIPC
+} // namespace IPC
  
  namespace WebKit {
  
@@ -38,7 +38,7 @@ public:
      {
      }
  
-    virtual void initializeConnection(CoreIPC::Connection*)
+    virtual void initializeConnection(IPC::Connection*)
      {
      }
  };
diff --git a/Source/WebKit2/Shared/ConnectionStack.h b/Source/WebKit2/Shared/ConnectionStack.h

index 6eea5ba..bd753a0 100644 (file)
--- a/Source/WebKit2/Shared/ConnectionStack.h
+++ b/Source/WebKit2/Shared/ConnectionStack.h
@@ -28,7 +28,7 @@
  
  #include <wtf/Vector.h>
  
-namespace CoreIPC {
+namespace IPC {
      class Connection;
  }
  
@@ -38,14 +38,14 @@ class ConnectionStack {
  public:
      static ConnectionStack& shared();
  
-    CoreIPC::Connection* current()
+    IPC::Connection* current()
      {
          return m_connectionStack.last();
      }
  
      class CurrentConnectionPusher {
      public:
-        CurrentConnectionPusher(ConnectionStack& connectionStack, CoreIPC::Connection* connection)
+        CurrentConnectionPusher(ConnectionStack& connectionStack, IPC::Connection* connection)
              : m_connectionStack(connectionStack)
  #if !ASSERT_DISABLED
              , m_connection(connection)
@@ -63,7 +63,7 @@ public:
      private:
          ConnectionStack& m_connectionStack;
  #if !ASSERT_DISABLED
-        CoreIPC::Connection* m_connection;
+        IPC::Connection* m_connection;
  #endif
      };
  
@@ -71,7 +71,7 @@ private:
      // It's OK for these to be weak pointers because we only push object on the stack
      // from within didReceiveMessage and didReceiveSyncMessage and the Connection objects are
      // already ref'd for the duration of those functions.
-    Vector<CoreIPC::Connection*, 4> m_connectionStack;
+    Vector<IPC::Connection*, 4> m_connectionStack;
  };
  
  } // namespace WebKit
diff --git a/Source/WebKit2/Shared/CoreIPCSupport/WebContextMessageKinds.h b/Source/WebKit2/Shared/CoreIPCSupport/WebContextMessageKinds.h

index a2dfba2..4895810 100644 (file)
--- a/Source/WebKit2/Shared/CoreIPCSupport/WebContextMessageKinds.h
+++ b/Source/WebKit2/Shared/CoreIPCSupport/WebContextMessageKinds.h
@@ -32,19 +32,19 @@
  
  namespace WebContextLegacyMessages {
  
-inline CoreIPC::StringReference messageReceiverName()
+inline IPC::StringReference messageReceiverName()
  {
-    return CoreIPC::StringReference("WebContextLegacyMessage");
+    return IPC::StringReference("WebContextLegacyMessage");
  }
  
-inline CoreIPC::StringReference postMessageMessageName()
+inline IPC::StringReference postMessageMessageName()
  {
-    return CoreIPC::StringReference("PostMessage");
+    return IPC::StringReference("PostMessage");
  }
  
-inline CoreIPC::StringReference postSynchronousMessageMessageName()
+inline IPC::StringReference postSynchronousMessageMessageName()
  {
-    return CoreIPC::StringReference("PostSynchronousMessage");
+    return IPC::StringReference("PostSynchronousMessage");
  }
  
  } // namespace WebContextLegacyMessages
diff --git a/Source/WebKit2/Shared/Databases/DatabaseProcessCreationParameters.cpp b/Source/WebKit2/Shared/Databases/DatabaseProcessCreationParameters.cpp

index c94adda..49f2cef 100644 (file)
--- a/Source/WebKit2/Shared/Databases/DatabaseProcessCreationParameters.cpp
+++ b/Source/WebKit2/Shared/Databases/DatabaseProcessCreationParameters.cpp
@@ -36,12 +36,12 @@ DatabaseProcessCreationParameters::DatabaseProcessCreationParameters()
  {
  }
  
-void DatabaseProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder) const
+void DatabaseProcessCreationParameters::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << indexedDatabaseDirectory;
  }
  
-bool DatabaseProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, DatabaseProcessCreationParameters& result)
+bool DatabaseProcessCreationParameters::decode(IPC::ArgumentDecoder& decoder, DatabaseProcessCreationParameters& result)
  {
      if (!decoder.decode(result.indexedDatabaseDirectory))
          return false;
diff --git a/Source/WebKit2/Shared/Databases/DatabaseProcessCreationParameters.h b/Source/WebKit2/Shared/Databases/DatabaseProcessCreationParameters.h

index eedc618..c3b637c 100644 (file)
--- a/Source/WebKit2/Shared/Databases/DatabaseProcessCreationParameters.h
+++ b/Source/WebKit2/Shared/Databases/DatabaseProcessCreationParameters.h
@@ -31,7 +31,7 @@
  
  #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
  
-namespace CoreIPC {
+namespace IPC {
  class ArgumentDecoder;
  class ArgumentEncoder;
  }
@@ -41,8 +41,8 @@ namespace WebKit {
  struct DatabaseProcessCreationParameters {
      DatabaseProcessCreationParameters();
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, DatabaseProcessCreationParameters&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, DatabaseProcessCreationParameters&);
  
      String indexedDatabaseDirectory;
  };
diff --git a/Source/WebKit2/Shared/DictionaryPopupInfo.cpp b/Source/WebKit2/Shared/DictionaryPopupInfo.cpp

index 13f0e85..e15dae6 100644 (file)
--- a/Source/WebKit2/Shared/DictionaryPopupInfo.cpp
+++ b/Source/WebKit2/Shared/DictionaryPopupInfo.cpp
@@ -34,7 +34,7 @@
  
  namespace WebKit {
  
-void DictionaryPopupInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
+void DictionaryPopupInfo::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << origin;
  
@@ -42,11 +42,11 @@ void DictionaryPopupInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
      bool hadOptions = options;
      encoder << hadOptions;
      if (hadOptions)
-        CoreIPC::encode(encoder, options.get());
+        IPC::encode(encoder, options.get());
  #endif
  }
  
-bool DictionaryPopupInfo::decode(CoreIPC::ArgumentDecoder& decoder, DictionaryPopupInfo& result)
+bool DictionaryPopupInfo::decode(IPC::ArgumentDecoder& decoder, DictionaryPopupInfo& result)
  {
      if (!decoder.decode(result.origin))
          return false;
@@ -55,7 +55,7 @@ bool DictionaryPopupInfo::decode(CoreIPC::ArgumentDecoder& decoder, DictionaryPo
      if (!decoder.decode(hadOptions))
          return false;
      if (hadOptions) {
-        if (!CoreIPC::decode(decoder, result.options))
+        if (!IPC::decode(decoder, result.options))
              return false;
      }
  #endif
diff --git a/Source/WebKit2/Shared/DictionaryPopupInfo.h b/Source/WebKit2/Shared/DictionaryPopupInfo.h

index 11c4514..7a0aa95 100644 (file)
--- a/Source/WebKit2/Shared/DictionaryPopupInfo.h
+++ b/Source/WebKit2/Shared/DictionaryPopupInfo.h
@@ -32,7 +32,7 @@
  #include <wtf/RetainPtr.h>
  #endif
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -40,8 +40,8 @@ namespace CoreIPC {
  namespace WebKit {
  
  struct DictionaryPopupInfo {
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, DictionaryPopupInfo&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, DictionaryPopupInfo&);
  
      WebCore::FloatPoint origin;
  #if PLATFORM(MAC)
diff --git a/Source/WebKit2/Shared/Downloads/Download.cpp b/Source/WebKit2/Shared/Downloads/Download.cpp

index 6f17e60..77229d7 100644 (file)
--- a/Source/WebKit2/Shared/Downloads/Download.cpp
+++ b/Source/WebKit2/Shared/Downloads/Download.cpp
@@ -130,7 +130,7 @@ void Download::didFinish()
      m_downloadManager.downloadFinished(this);
  }
  
-void Download::didFail(const ResourceError& error, const CoreIPC::DataReference& resumeData)
+void Download::didFail(const ResourceError& error, const IPC::DataReference& resumeData)
  {
      send(Messages::DownloadProxy::DidFail(error, resumeData));
  
@@ -141,7 +141,7 @@ void Download::didFail(const ResourceError& error, const CoreIPC::DataReference&
      m_downloadManager.downloadFinished(this);
  }
  
-void Download::didCancel(const CoreIPC::DataReference& resumeData)
+void Download::didCancel(const IPC::DataReference& resumeData)
  {
      send(Messages::DownloadProxy::DidCancel(resumeData));
  
@@ -152,7 +152,7 @@ void Download::didCancel(const CoreIPC::DataReference& resumeData)
      m_downloadManager.downloadFinished(this);
  }
  
-CoreIPC::Connection* Download::messageSenderConnection()
+IPC::Connection* Download::messageSenderConnection()
  {
      return m_downloadManager.downloadProxyConnection();
  }
diff --git a/Source/WebKit2/Shared/Downloads/Download.h b/Source/WebKit2/Shared/Downloads/Download.h

index f67a7b5..6f38b90 100644 (file)
--- a/Source/WebKit2/Shared/Downloads/Download.h
+++ b/Source/WebKit2/Shared/Downloads/Download.h
@@ -46,7 +46,7 @@ OBJC_CLASS WKDownloadAsDelegate;
  #include <CFNetwork/CFURLDownloadPriv.h>
  #endif
  
-namespace CoreIPC {
+namespace IPC {
      class DataReference;
  }
  
@@ -65,7 +65,7 @@ class DownloadManager;
  class SandboxExtension;
  class WebPage;
  
-class Download : public CoreIPC::MessageSender {
+class Download : public IPC::MessageSender {
      WTF_MAKE_NONCOPYABLE(Download);
  public:
      Download(DownloadManager&, uint64_t downloadID, const WebCore::ResourceRequest&);
@@ -86,8 +86,8 @@ public:
      void didCreateDestination(const String& path);
      void didFinish();
      void platformDidFinish();
-    void didFail(const WebCore::ResourceError&, const CoreIPC::DataReference& resumeData);
-    void didCancel(const CoreIPC::DataReference& resumeData);
+    void didFail(const WebCore::ResourceError&, const IPC::DataReference& resumeData);
+    void didCancel(const IPC::DataReference& resumeData);
      void didDecideDestination(const String&, bool allowOverwrite);
  
  #if USE(CFNETWORK)
@@ -105,8 +105,8 @@ public:
      void cancelAuthenticationChallenge(const WebCore::AuthenticationChallenge&);
  
  private:
-    // CoreIPC::MessageSender
-    virtual CoreIPC::Connection* messageSenderConnection() OVERRIDE;
+    // IPC::MessageSender
+    virtual IPC::Connection* messageSenderConnection() OVERRIDE;
      virtual uint64_t messageSenderDestinationID() OVERRIDE;
  
      void platformInvalidate();
diff --git a/Source/WebKit2/Shared/Downloads/DownloadManager.cpp b/Source/WebKit2/Shared/Downloads/DownloadManager.cpp

index df353d8..a1d6506 100644 (file)
--- a/Source/WebKit2/Shared/Downloads/DownloadManager.cpp
+++ b/Source/WebKit2/Shared/Downloads/DownloadManager.cpp
@@ -81,7 +81,7 @@ void DownloadManager::didDestroyDownload()
      m_client->didDestroyDownload();
  }
  
-CoreIPC::Connection* DownloadManager::downloadProxyConnection()
+IPC::Connection* DownloadManager::downloadProxyConnection()
  {
      return m_client->downloadProxyConnection();
  }
diff --git a/Source/WebKit2/Shared/Downloads/DownloadManager.h b/Source/WebKit2/Shared/Downloads/DownloadManager.h

index e5ffffa..2a1694e 100644 (file)
--- a/Source/WebKit2/Shared/Downloads/DownloadManager.h
+++ b/Source/WebKit2/Shared/Downloads/DownloadManager.h
@@ -36,7 +36,7 @@ class ResourceRequest;
  class ResourceResponse;
  }
  
-namespace CoreIPC {
+namespace IPC {
  class Connection;
  }
  
@@ -56,7 +56,7 @@ public:
  
          virtual void didCreateDownload() = 0;
          virtual void didDestroyDownload() = 0;
-        virtual CoreIPC::Connection* downloadProxyConnection() = 0;
+        virtual IPC::Connection* downloadProxyConnection() = 0;
          virtual AuthenticationManager& downloadsAuthenticationManager() = 0;
      };
  
@@ -74,7 +74,7 @@ public:
      void didCreateDownload();
      void didDestroyDownload();
  
-    CoreIPC::Connection* downloadProxyConnection();
+    IPC::Connection* downloadProxyConnection();
      AuthenticationManager& downloadsAuthenticationManager();
  
  private:
diff --git a/Source/WebKit2/Shared/Downloads/mac/DownloadMac.mm b/Source/WebKit2/Shared/Downloads/mac/DownloadMac.mm

index 9c1de83..d2e804d 100644 (file)
--- a/Source/WebKit2/Shared/Downloads/mac/DownloadMac.mm
+++ b/Source/WebKit2/Shared/Downloads/mac/DownloadMac.mm
@@ -87,7 +87,7 @@ void Download::cancel()
      [m_nsURLDownload.get() cancel];
  
      RetainPtr<NSData> resumeData = [m_nsURLDownload.get() resumeData];
-    didCancel(CoreIPC::DataReference(reinterpret_cast<const uint8_t*>([resumeData.get() bytes]), [resumeData.get() length]));
+    didCancel(IPC::DataReference(reinterpret_cast<const uint8_t*>([resumeData.get() bytes]), [resumeData.get() length]));
  }
  
  void Download::platformInvalidate()
@@ -263,7 +263,7 @@ static void dispatchOnMainThread(void (^block)())
              return;
  
          RetainPtr<NSData> resumeData = [download resumeData];
-        CoreIPC::DataReference dataReference(reinterpret_cast<const uint8_t*>([resumeData.get() bytes]), [resumeData.get() length]);
+        IPC::DataReference dataReference(reinterpret_cast<const uint8_t*>([resumeData.get() bytes]), [resumeData.get() length]);
  
          _download->didFail(error, dataReference);
      });
diff --git a/Source/WebKit2/Shared/EditorState.cpp b/Source/WebKit2/Shared/EditorState.cpp

index 30ee206..3593d7b 100644 (file)
--- a/Source/WebKit2/Shared/EditorState.cpp
+++ b/Source/WebKit2/Shared/EditorState.cpp
@@ -35,7 +35,7 @@
  
  namespace WebKit {
  
-void EditorState::encode(CoreIPC::ArgumentEncoder& encoder) const
+void EditorState::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << shouldIgnoreCompositionSelectionChange;
      encoder << selectionIsNone;
@@ -62,7 +62,7 @@ void EditorState::encode(CoreIPC::ArgumentEncoder& encoder) const
  #endif
  }
  
-bool EditorState::decode(CoreIPC::ArgumentDecoder& decoder, EditorState& result)
+bool EditorState::decode(IPC::ArgumentDecoder& decoder, EditorState& result)
  {
      if (!decoder.decode(result.shouldIgnoreCompositionSelectionChange))
          return false;
diff --git a/Source/WebKit2/Shared/EditorState.h b/Source/WebKit2/Shared/EditorState.h

index 444ca44..61b5014 100644 (file)
--- a/Source/WebKit2/Shared/EditorState.h
+++ b/Source/WebKit2/Shared/EditorState.h
@@ -77,8 +77,8 @@ struct EditorState {
      WebCore::IntRect cursorRect;
  #endif
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, EditorState&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, EditorState&);
  };
  
  }
diff --git a/Source/WebKit2/Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.h b/Source/WebKit2/Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.h

index 91e2976..dbf0a1f 100644 (file)
--- a/Source/WebKit2/Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.h
+++ b/Source/WebKit2/Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.h
@@ -47,7 +47,7 @@ public:
      virtual void installSignalHandlers();
      virtual void doPreInitializationWork();
  
-    virtual bool getConnectionIdentifier(CoreIPC::Connection::Identifier& identifier);
+    virtual bool getConnectionIdentifier(IPC::Connection::Identifier& identifier);
      virtual bool getClientIdentifier(String& clientIdentifier);
      virtual bool getClientProcessName(String& clientProcessName);
      virtual bool getExtraInitializationData(HashMap<String, String>& extraInitializationData);
diff --git a/Source/WebKit2/Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.mm b/Source/WebKit2/Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.mm

index 5f8ff4e..13f306e 100644 (file)
--- a/Source/WebKit2/Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.mm
+++ b/Source/WebKit2/Shared/EntryPointUtilities/mac/LegacyProcess/ChildProcessEntryPoint.mm
@@ -55,7 +55,7 @@ void ChildProcessMainDelegate::doPreInitializationWork()
  {
  }
  
-bool ChildProcessMainDelegate::getConnectionIdentifier(CoreIPC::Connection::Identifier& identifier)
+bool ChildProcessMainDelegate::getConnectionIdentifier(IPC::Connection::Identifier& identifier)
  {
      String serviceName = m_commandLine["servicename"];
      if (serviceName.isEmpty())
diff --git a/Source/WebKit2/Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.h b/Source/WebKit2/Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.h

index a9e8183..7633161 100644 (file)
--- a/Source/WebKit2/Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.h
+++ b/Source/WebKit2/Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.h
@@ -42,7 +42,7 @@ public:
  
      virtual ~XPCServiceInitializerDelegate();
  
-    virtual bool getConnectionIdentifier(CoreIPC::Connection::Identifier& identifier);
+    virtual bool getConnectionIdentifier(IPC::Connection::Identifier& identifier);
      virtual bool getClientIdentifier(String& clientIdentifier);
      virtual bool getClientProcessName(String& clientProcessName);
      virtual bool getExtraInitializationData(HashMap<String, String>& extraInitializationData);
diff --git a/Source/WebKit2/Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.mm b/Source/WebKit2/Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.mm

index 63dd785..6dd5dbe 100644 (file)
--- a/Source/WebKit2/Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.mm
+++ b/Source/WebKit2/Shared/EntryPointUtilities/mac/XPCService/XPCServiceEntryPoint.mm
@@ -35,9 +35,9 @@ XPCServiceInitializerDelegate::~XPCServiceInitializerDelegate()
  {
  }
  
-bool XPCServiceInitializerDelegate::getConnectionIdentifier(CoreIPC::Connection::Identifier& identifier)
+bool XPCServiceInitializerDelegate::getConnectionIdentifier(IPC::Connection::Identifier& identifier)
  {
-    identifier = CoreIPC::Connection::Identifier(xpc_dictionary_copy_mach_send(m_initializerMessage, "server-port"), m_connection);
+    identifier = IPC::Connection::Identifier(xpc_dictionary_copy_mach_send(m_initializerMessage, "server-port"), m_connection);
      return true;
  }
  
diff --git a/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.cpp b/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.cpp

index 47dea9f..24939a9 100644 (file)
--- a/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.cpp
+++ b/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.cpp
@@ -70,7 +70,7 @@ std::unique_ptr<BlobData> BlobRegistrationData::releaseData() const
      return std::move(m_data);
  }
  
-void BlobRegistrationData::encode(CoreIPC::ArgumentEncoder& encoder) const
+void BlobRegistrationData::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_data->contentType();
      encoder << m_data->contentDisposition();
@@ -85,7 +85,7 @@ void BlobRegistrationData::encode(CoreIPC::ArgumentEncoder& encoder) const
              // There is no way to create a partial data item.
              ASSERT(!item.offset);
              ASSERT(item.length == BlobDataItem::toEndOfFile);
-            encoder << CoreIPC::DataReference(reinterpret_cast<const uint8_t*>(item.data->data()), item.data->length());
+            encoder << IPC::DataReference(reinterpret_cast<const uint8_t*>(item.data->data()), item.data->length());
              break;
          case BlobDataItem::File:
              encoder << static_cast<int64_t>(item.offset);
@@ -104,7 +104,7 @@ void BlobRegistrationData::encode(CoreIPC::ArgumentEncoder& encoder) const
      encoder << m_sandboxExtensions;
  }
  
-bool BlobRegistrationData::decode(CoreIPC::ArgumentDecoder& decoder, BlobRegistrationData& result)
+bool BlobRegistrationData::decode(IPC::ArgumentDecoder& decoder, BlobRegistrationData& result)
  {
      ASSERT(!result.m_data);
      result.m_data = std::make_unique<BlobData>();
@@ -129,7 +129,7 @@ bool BlobRegistrationData::decode(CoreIPC::ArgumentDecoder& decoder, BlobRegistr
              return false;
          switch (type) {
          case BlobDataItem::Data: {
-            CoreIPC::DataReference data;
+            IPC::DataReference data;
              if (!decoder.decode(data))
                  return false;
              RefPtr<RawData> rawData = RawData::create();
diff --git a/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.h b/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.h

index b485131..71f9c09 100644 (file)
--- a/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.h
+++ b/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.h
@@ -43,8 +43,8 @@ public:
      BlobRegistrationData(std::unique_ptr<WebCore::BlobData>);
      ~BlobRegistrationData();
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, BlobRegistrationData&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, BlobRegistrationData&);
  
      std::unique_ptr<WebCore::BlobData> releaseData() const;
      const SandboxExtension::HandleArray& sandboxExtensions() const { return m_sandboxExtensions; }
diff --git a/Source/WebKit2/Shared/FontInfo.cpp b/Source/WebKit2/Shared/FontInfo.cpp

index ab64598..7743d72 100644 (file)
--- a/Source/WebKit2/Shared/FontInfo.cpp
+++ b/Source/WebKit2/Shared/FontInfo.cpp
@@ -34,18 +34,18 @@
  
  namespace WebKit {
  
-void FontInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
+void FontInfo::encode(IPC::ArgumentEncoder& encoder) const
  {
  #if PLATFORM(MAC)
      encoder << static_cast<bool>(fontAttributeDictionary);
      if (fontAttributeDictionary)
-        CoreIPC::encode(encoder, fontAttributeDictionary.get());
+        IPC::encode(encoder, fontAttributeDictionary.get());
  #else
      UNUSED_PARAM(encoder);
  #endif
  }
  
-bool FontInfo::decode(CoreIPC::ArgumentDecoder& decoder, FontInfo& fontInfo)
+bool FontInfo::decode(IPC::ArgumentDecoder& decoder, FontInfo& fontInfo)
  {    
  #if PLATFORM(MAC)
      bool hasFontAttributeDictionary;
@@ -55,7 +55,7 @@ bool FontInfo::decode(CoreIPC::ArgumentDecoder& decoder, FontInfo& fontInfo)
      if (!hasFontAttributeDictionary)
          return true;
  
-    if (!CoreIPC::decode(decoder, fontInfo.fontAttributeDictionary))
+    if (!IPC::decode(decoder, fontInfo.fontAttributeDictionary))
          return false;
  #else
      UNUSED_PARAM(decoder);
diff --git a/Source/WebKit2/Shared/FontInfo.h b/Source/WebKit2/Shared/FontInfo.h

index e124f25..8f15635 100644 (file)
--- a/Source/WebKit2/Shared/FontInfo.h
+++ b/Source/WebKit2/Shared/FontInfo.h
@@ -30,7 +30,7 @@
  #include <wtf/RetainPtr.h>
  #endif
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -38,8 +38,8 @@ namespace CoreIPC {
  namespace WebKit {
      
  struct FontInfo {
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, FontInfo&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, FontInfo&);
      
  #if PLATFORM(MAC)
      RetainPtr<CFDictionaryRef> fontAttributeDictionary;
diff --git a/Source/WebKit2/Shared/LayerTreeContext.h b/Source/WebKit2/Shared/LayerTreeContext.h

index 03b1d68..94296fb 100644 (file)
--- a/Source/WebKit2/Shared/LayerTreeContext.h
+++ b/Source/WebKit2/Shared/LayerTreeContext.h
@@ -28,7 +28,7 @@
  
  #include <stdint.h>
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -47,8 +47,8 @@ public:
      LayerTreeContext();
      ~LayerTreeContext();
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, LayerTreeContext&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, LayerTreeContext&);
  
      bool isEmpty() const;
  
diff --git a/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.h b/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.h

index d34ffbf..505107e 100644 (file)
--- a/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.h
+++ b/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.h
@@ -43,9 +43,9 @@ OBJC_CLASS WKCustomProtocol;
  #endif
  
  
-namespace CoreIPC {
+namespace IPC {
  class DataReference;
-} // namespace CoreIPC
+} // namespace IPC
  
  namespace WebCore {
  class ResourceError;
@@ -57,7 +57,7 @@ namespace WebKit {
  class ChildProcess;
  struct NetworkProcessCreationParameters;
  
-class CustomProtocolManager : public WebProcessSupplement, public NetworkProcessSupplement, public CoreIPC::Connection::WorkQueueMessageReceiver {
+class CustomProtocolManager : public WebProcessSupplement, public NetworkProcessSupplement, public IPC::Connection::WorkQueueMessageReceiver {
      WTF_MAKE_NONCOPYABLE(CustomProtocolManager);
  public:
      explicit CustomProtocolManager(ChildProcess*);
@@ -77,7 +77,7 @@ public:
  
  private:
      // ChildProcessSupplement
-    void initializeConnection(CoreIPC::Connection*) OVERRIDE;
+    void initializeConnection(IPC::Connection*) OVERRIDE;
  
      // WebProcessSupplement
      void initialize(const WebProcessCreationParameters&) OVERRIDE;
@@ -87,11 +87,11 @@ private:
      void initialize(const NetworkProcessCreationParameters&) OVERRIDE;
  #endif
  
-    // CoreIPC::MessageReceiver
-    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
+    // IPC::MessageReceiver
+    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) OVERRIDE;
  
      void didFailWithError(uint64_t customProtocolID, const WebCore::ResourceError&);
-    void didLoadData(uint64_t customProtocolID, const CoreIPC::DataReference&);
+    void didLoadData(uint64_t customProtocolID, const IPC::DataReference&);
      void didReceiveResponse(uint64_t customProtocolID, const WebCore::ResourceResponse&, uint32_t cacheStoragePolicy);
      void didFinishLoading(uint64_t customProtocolID);
  
diff --git a/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.messages.in b/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.messages.in

index ca51560..2376d92 100644 (file)
--- a/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.messages.in
+++ b/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.messages.in
@@ -24,7 +24,7 @@
  
  messages -> CustomProtocolManager {
      DidFailWithError(uint64_t customProtocolID, WebCore::ResourceError error)
-    DidLoadData(uint64_t customProtocolID, CoreIPC::DataReference data)
+    DidLoadData(uint64_t customProtocolID, IPC::DataReference data)
      DidReceiveResponse(uint64_t customProtocolID, WebCore::ResourceResponse response, uint32_t cacheStoragePolicy)
      DidFinishLoading(uint64_t customProtocolID)
  
diff --git a/Source/WebKit2/Shared/Network/CustomProtocols/mac/CustomProtocolManagerMac.mm b/Source/WebKit2/Shared/Network/CustomProtocols/mac/CustomProtocolManagerMac.mm

index 7983a77..1fec7d5 100644 (file)
--- a/Source/WebKit2/Shared/Network/CustomProtocols/mac/CustomProtocolManagerMac.mm
+++ b/Source/WebKit2/Shared/Network/CustomProtocols/mac/CustomProtocolManagerMac.mm
@@ -132,7 +132,7 @@ CustomProtocolManager::CustomProtocolManager(ChildProcess* childProcess)
      sharedCustomProtocolManager = this;
  }
  
-void CustomProtocolManager::initializeConnection(CoreIPC::Connection* connection)
+void CustomProtocolManager::initializeConnection(IPC::Connection* connection)
  {
      connection->addWorkQueueMessageReceiver(Messages::CustomProtocolManager::messageReceiverName(), m_messageQueue.get(), this);
  }
@@ -222,7 +222,7 @@ void CustomProtocolManager::didFailWithError(uint64_t customProtocolID, const We
      removeCustomProtocol(protocol.get());
  }
  
-void CustomProtocolManager::didLoadData(uint64_t customProtocolID, const CoreIPC::DataReference& data)
+void CustomProtocolManager::didLoadData(uint64_t customProtocolID, const IPC::DataReference& data)
  {
      RetainPtr<WKCustomProtocol> protocol = protocolForID(customProtocolID);
      if (!protocol)
diff --git a/Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.cpp b/Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.cpp

index d1ebfc7..f267c66 100644 (file)
--- a/Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.cpp
+++ b/Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.cpp
@@ -36,7 +36,7 @@ NetworkProcessCreationParameters::NetworkProcessCreationParameters()
  {
  }
  
-void NetworkProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder) const
+void NetworkProcessCreationParameters::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << privateBrowsingEnabled;
      encoder.encodeEnum(cacheModel);
@@ -62,7 +62,7 @@ void NetworkProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder)
  #endif
  }
  
-bool NetworkProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, NetworkProcessCreationParameters& result)
+bool NetworkProcessCreationParameters::decode(IPC::ArgumentDecoder& decoder, NetworkProcessCreationParameters& result)
  {
      if (!decoder.decode(result.privateBrowsingEnabled))
          return false;
diff --git a/Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.h b/Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.h

index 6429052..e89889b 100644 (file)
--- a/Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.h
+++ b/Source/WebKit2/Shared/Network/NetworkProcessCreationParameters.h
@@ -37,7 +37,7 @@
  #include "HTTPCookieAcceptPolicy.h"
  #endif
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -47,8 +47,8 @@ namespace WebKit {
  struct NetworkProcessCreationParameters {
      NetworkProcessCreationParameters();
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, NetworkProcessCreationParameters&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, NetworkProcessCreationParameters&);
  
      bool privateBrowsingEnabled;
      CacheModel cacheModel;
diff --git a/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.cpp b/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.cpp

index 99d1d46..57a0571 100644 (file)
--- a/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.cpp
+++ b/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.cpp
@@ -51,7 +51,7 @@ NetworkResourceLoadParameters::NetworkResourceLoadParameters()
  {
  }
  
-void NetworkResourceLoadParameters::encode(CoreIPC::ArgumentEncoder& encoder) const
+void NetworkResourceLoadParameters::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << identifier;
      encoder << webPageID;
@@ -99,7 +99,7 @@ void NetworkResourceLoadParameters::encode(CoreIPC::ArgumentEncoder& encoder) co
      encoder << isMainResource;
  }
  
-bool NetworkResourceLoadParameters::decode(CoreIPC::ArgumentDecoder& decoder, NetworkResourceLoadParameters& result)
+bool NetworkResourceLoadParameters::decode(IPC::ArgumentDecoder& decoder, NetworkResourceLoadParameters& result)
  {
      if (!decoder.decode(result.identifier))
          return false;
@@ -118,7 +118,7 @@ bool NetworkResourceLoadParameters::decode(CoreIPC::ArgumentDecoder& decoder, Ne
          return false;
  
      if (hasHTTPBody) {
-        CoreIPC::DataReference formData;
+        IPC::DataReference formData;
          if (!decoder.decode(formData))
              return false;
          DecoderAdapter httpBodyDecoderAdapter(formData.data(), formData.size());
diff --git a/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.h b/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.h

index f26bb1d..ace0634 100644 (file)
--- a/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.h
+++ b/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.h
@@ -33,7 +33,7 @@
  
  #if ENABLE(NETWORK_PROCESS)
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -46,8 +46,8 @@ class NetworkResourceLoadParameters {
  public:
      NetworkResourceLoadParameters();
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, NetworkResourceLoadParameters&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, NetworkResourceLoadParameters&);
  
      ResourceLoadIdentifier identifier;
      uint64_t webPageID;
diff --git a/Source/WebKit2/Shared/OriginAndDatabases.cpp b/Source/WebKit2/Shared/OriginAndDatabases.cpp

index 4745b9c..94f49b8 100644 (file)
--- a/Source/WebKit2/Shared/OriginAndDatabases.cpp
+++ b/Source/WebKit2/Shared/OriginAndDatabases.cpp
@@ -34,7 +34,7 @@ using namespace WebCore;
  
  namespace WebKit {
  
-void OriginAndDatabases::encode(CoreIPC::ArgumentEncoder& encoder) const
+void OriginAndDatabases::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << originIdentifier;
      encoder << originQuota;
@@ -42,7 +42,7 @@ void OriginAndDatabases::encode(CoreIPC::ArgumentEncoder& encoder) const
      encoder << databases;
  }
  
-bool OriginAndDatabases::decode(CoreIPC::ArgumentDecoder& decoder, OriginAndDatabases& originAndDatabases)
+bool OriginAndDatabases::decode(IPC::ArgumentDecoder& decoder, OriginAndDatabases& originAndDatabases)
  {
      if (!decoder.decode(originAndDatabases.originIdentifier))
          return false;
diff --git a/Source/WebKit2/Shared/OriginAndDatabases.h b/Source/WebKit2/Shared/OriginAndDatabases.h

index b7b389a..487338f 100644 (file)
--- a/Source/WebKit2/Shared/OriginAndDatabases.h
+++ b/Source/WebKit2/Shared/OriginAndDatabases.h
@@ -32,7 +32,7 @@
  #include <wtf/Vector.h>
  #include <wtf/text/WTFString.h>
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -40,8 +40,8 @@ namespace CoreIPC {
  namespace WebKit {
  
  struct OriginAndDatabases {
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, OriginAndDatabases&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, OriginAndDatabases&);
  
      String originIdentifier;
      uint64_t originQuota;
diff --git a/Source/WebKit2/Shared/PlatformPopupMenuData.cpp b/Source/WebKit2/Shared/PlatformPopupMenuData.cpp

index e857b64..49da130 100644 (file)
--- a/Source/WebKit2/Shared/PlatformPopupMenuData.cpp
+++ b/Source/WebKit2/Shared/PlatformPopupMenuData.cpp
@@ -34,7 +34,7 @@ PlatformPopupMenuData::PlatformPopupMenuData()
  {
  }
  
-void PlatformPopupMenuData::encode(CoreIPC::ArgumentEncoder& encoder) const
+void PlatformPopupMenuData::encode(IPC::ArgumentEncoder& encoder) const
  {
  #if PLATFORM(MAC)
      encoder << fontInfo;
@@ -44,7 +44,7 @@ void PlatformPopupMenuData::encode(CoreIPC::ArgumentEncoder& encoder) const
  #endif
  }
  
-bool PlatformPopupMenuData::decode(CoreIPC::ArgumentDecoder& decoder, PlatformPopupMenuData& data)
+bool PlatformPopupMenuData::decode(IPC::ArgumentDecoder& decoder, PlatformPopupMenuData& data)
  {
  #if PLATFORM(MAC)
      if (!decoder.decode(data.fontInfo))
diff --git a/Source/WebKit2/Shared/PlatformPopupMenuData.h b/Source/WebKit2/Shared/PlatformPopupMenuData.h

index 0d42e68..10207fe 100644 (file)
--- a/Source/WebKit2/Shared/PlatformPopupMenuData.h
+++ b/Source/WebKit2/Shared/PlatformPopupMenuData.h
@@ -30,7 +30,7 @@
  #include "ShareableBitmap.h"
  #include <wtf/text/WTFString.h>
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -40,8 +40,8 @@ namespace WebKit {
  struct PlatformPopupMenuData {
      PlatformPopupMenuData();
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, PlatformPopupMenuData&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, PlatformPopupMenuData&);
  
  #if PLATFORM(MAC)
      FontInfo fontInfo;
diff --git a/Source/WebKit2/Shared/Plugins/NPIdentifierData.cpp b/Source/WebKit2/Shared/Plugins/NPIdentifierData.cpp

index fd059d4..029e6ab 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/NPIdentifierData.cpp
+++ b/Source/WebKit2/Shared/Plugins/NPIdentifierData.cpp
@@ -67,7 +67,7 @@ NPIdentifier NPIdentifierData::createNPIdentifier() const
      return static_cast<NPIdentifier>(IdentifierRep::get(m_number));
  }
  
-void NPIdentifierData::encode(CoreIPC::ArgumentEncoder& encoder) const
+void NPIdentifierData::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_isString;
      if (m_isString)
@@ -76,7 +76,7 @@ void NPIdentifierData::encode(CoreIPC::ArgumentEncoder& encoder) const
          encoder << m_number;
  }
  
-bool NPIdentifierData::decode(CoreIPC::ArgumentDecoder& decoder, NPIdentifierData& result)
+bool NPIdentifierData::decode(IPC::ArgumentDecoder& decoder, NPIdentifierData& result)
  {
      if (!decoder.decode(result.m_isString))
          return false;
diff --git a/Source/WebKit2/Shared/Plugins/NPIdentifierData.h b/Source/WebKit2/Shared/Plugins/NPIdentifierData.h

index 0c42adf..5b51793 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/NPIdentifierData.h
+++ b/Source/WebKit2/Shared/Plugins/NPIdentifierData.h
@@ -31,15 +31,13 @@
  #include <WebCore/npruntime_internal.h>
  #include <wtf/text/CString.h>
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
  
  namespace WebKit {
  
-// The CoreIPC representation of an NPIdentifier.
-
  class NPIdentifierData {
  public:
      NPIdentifierData();
@@ -47,8 +45,8 @@ public:
      static NPIdentifierData fromNPIdentifier(NPIdentifier);
      NPIdentifier createNPIdentifier() const;
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, NPIdentifierData&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, NPIdentifierData&);
  
  private:
      bool m_isString;
diff --git a/Source/WebKit2/Shared/Plugins/NPObjectMessageReceiver.h b/Source/WebKit2/Shared/Plugins/NPObjectMessageReceiver.h

index 6c8cc92..ee14d6d 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/NPObjectMessageReceiver.h
+++ b/Source/WebKit2/Shared/Plugins/NPObjectMessageReceiver.h
@@ -46,7 +46,7 @@ public:
      NPObjectMessageReceiver(NPRemoteObjectMap*, Plugin*, uint64_t npObjectID, NPObject*);
      ~NPObjectMessageReceiver();
  
-    void didReceiveSyncNPObjectMessageReceiverMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&);
+    void didReceiveSyncNPObjectMessageReceiverMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
  
      Plugin* plugin() const { return m_plugin; }
      NPObject* npObject() const { return m_npObject; }
diff --git a/Source/WebKit2/Shared/Plugins/NPRemoteObjectMap.cpp b/Source/WebKit2/Shared/Plugins/NPRemoteObjectMap.cpp

index 20b5ba0..8138c2f 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/NPRemoteObjectMap.cpp
+++ b/Source/WebKit2/Shared/Plugins/NPRemoteObjectMap.cpp
@@ -42,12 +42,12 @@ static uint64_t generateNPObjectID()
      return ++generateNPObjectID;
  }
  
-PassRefPtr<NPRemoteObjectMap> NPRemoteObjectMap::create(CoreIPC::Connection* connection)
+PassRefPtr<NPRemoteObjectMap> NPRemoteObjectMap::create(IPC::Connection* connection)
  {
      return adoptRef(new NPRemoteObjectMap(connection));
  }
  
-NPRemoteObjectMap::NPRemoteObjectMap(CoreIPC::Connection* connection)
+NPRemoteObjectMap::NPRemoteObjectMap(IPC::Connection* connection)
      : m_connection(connection)
  {
  }
@@ -227,7 +227,7 @@ void NPRemoteObjectMap::pluginDestroyed(Plugin* plugin)
      }
  }
  
-void NPRemoteObjectMap::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, std::unique_ptr<CoreIPC::MessageEncoder>& replyEncoder)
+void NPRemoteObjectMap::didReceiveSyncMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
  {
      NPObjectMessageReceiver* messageReceiver = m_registeredNPObjects.get(decoder.destinationID());
      if (!messageReceiver)
diff --git a/Source/WebKit2/Shared/Plugins/NPRemoteObjectMap.h b/Source/WebKit2/Shared/Plugins/NPRemoteObjectMap.h

index 5c8a473..cd075f8 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/NPRemoteObjectMap.h
+++ b/Source/WebKit2/Shared/Plugins/NPRemoteObjectMap.h
@@ -43,7 +43,7 @@ class Plugin;
  
  class NPRemoteObjectMap : public RefCounted<NPRemoteObjectMap> {
  public:
-    static PassRefPtr<NPRemoteObjectMap> create(CoreIPC::Connection*);
+    static PassRefPtr<NPRemoteObjectMap> create(IPC::Connection*);
      ~NPRemoteObjectMap();
  
      // Creates an NPObjectProxy wrapper for the remote object with the given remote object ID.
@@ -54,21 +54,18 @@ public:
      uint64_t registerNPObject(NPObject*, Plugin*);
      void unregisterNPObject(uint64_t);
  
-    // Given an NPVariant, creates an NPVariantData object (a CoreIPC representation of an NPVariant).
      NPVariantData npVariantToNPVariantData(const NPVariant&, Plugin*);
-
-    // Given an NPVariantData, creates an NPVariant object.
      NPVariant npVariantDataToNPVariant(const NPVariantData&, Plugin*);
  
-    CoreIPC::Connection* connection() const { return m_connection; }
+    IPC::Connection* connection() const { return m_connection; }
  
      void pluginDestroyed(Plugin*);
  
-    void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, std::unique_ptr<CoreIPC::MessageEncoder>&);
+    void didReceiveSyncMessage(IPC::Connection*, IPC::MessageDecoder&, std::unique_ptr<IPC::MessageEncoder>&);
  
  private:
-    explicit NPRemoteObjectMap(CoreIPC::Connection*);
-    CoreIPC::Connection* m_connection;
+    explicit NPRemoteObjectMap(IPC::Connection*);
+    IPC::Connection* m_connection;
  
      // A map of NPObjectMessageReceiver classes, wrapping objects that we export to the
      // other end of the connection.
diff --git a/Source/WebKit2/Shared/Plugins/NPVariantData.cpp b/Source/WebKit2/Shared/Plugins/NPVariantData.cpp

index 029a6d0..b460d09 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/NPVariantData.cpp
+++ b/Source/WebKit2/Shared/Plugins/NPVariantData.cpp
@@ -118,7 +118,7 @@ NPVariantData NPVariantData::makeRemoteNPObjectID(uint64_t value)
      return npVariantData;
  }
  
-void NPVariantData::encode(CoreIPC::ArgumentEncoder& encoder) const
+void NPVariantData::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_type;
  
@@ -147,7 +147,7 @@ void NPVariantData::encode(CoreIPC::ArgumentEncoder& encoder) const
      }
  }
  
-bool NPVariantData::decode(CoreIPC::ArgumentDecoder& decoder, NPVariantData& result)
+bool NPVariantData::decode(IPC::ArgumentDecoder& decoder, NPVariantData& result)
  {
      uint32_t type;
      if (!decoder.decode(type))
diff --git a/Source/WebKit2/Shared/Plugins/NPVariantData.h b/Source/WebKit2/Shared/Plugins/NPVariantData.h

index 66be03a..da056a9 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/NPVariantData.h
+++ b/Source/WebKit2/Shared/Plugins/NPVariantData.h
@@ -30,15 +30,13 @@
  
  #include <wtf/text/CString.h>
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
  
  namespace WebKit {
  
-// The CoreIPC representation of an NPVariant.
-
  class NPVariantData {
  public:
      enum Type {
@@ -100,8 +98,8 @@ public:
          return m_remoteNPObjectIDValue;
      }
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, NPVariantData&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, NPVariantData&);
  
  private:
      uint32_t m_type;
diff --git a/Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.cpp b/Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.cpp

index 89ea7d1..a53fdef 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.cpp
+++ b/Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.cpp
@@ -37,7 +37,7 @@ PluginProcessCreationParameters::PluginProcessCreationParameters()
  {
  }
  
-void PluginProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder) const
+void PluginProcessCreationParameters::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder.encodeEnum(processType);
      encoder << supportsAsynchronousPluginInitialization;
@@ -48,7 +48,7 @@ void PluginProcessCreationParameters::encode(CoreIPC::ArgumentEncoder& encoder)
  #endif
  }
  
-bool PluginProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, PluginProcessCreationParameters& result)
+bool PluginProcessCreationParameters::decode(IPC::ArgumentDecoder& decoder, PluginProcessCreationParameters& result)
  {
      if (!decoder.decodeEnum(result.processType))
          return false;
diff --git a/Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.h b/Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.h

index b94c66b..e0f9d6b 100644 (file)
--- a/Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.h
+++ b/Source/WebKit2/Shared/Plugins/PluginProcessCreationParameters.h
@@ -34,7 +34,7 @@
  #include "MachPort.h"
  #endif
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -44,8 +44,8 @@ namespace WebKit {
  struct PluginProcessCreationParameters {
      PluginProcessCreationParameters();
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, PluginProcessCreationParameters&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, PluginProcessCreationParameters&);
  
      PluginProcessType processType;
      bool supportsAsynchronousPluginInitialization;
@@ -54,7 +54,7 @@ struct PluginProcessCreationParameters {
      double terminationTimeout;
  
  #if PLATFORM(MAC)
-    CoreIPC::MachPort acceleratedCompositingPort;
+    IPC::MachPort acceleratedCompositingPort;
  #endif
  };
  
diff --git a/Source/WebKit2/Shared/PrintInfo.cpp b/Source/WebKit2/Shared/PrintInfo.cpp

index e57ff72..bbdcba7 100644 (file)
--- a/Source/WebKit2/Shared/PrintInfo.cpp
+++ b/Source/WebKit2/Shared/PrintInfo.cpp
@@ -43,20 +43,20 @@ PrintInfo::PrintInfo()
  {
  }
  
-void PrintInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
+void PrintInfo::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << pageSetupScaleFactor;
      encoder << availablePaperWidth;
      encoder << availablePaperHeight;
  
  #if PLATFORM(GTK)
-    CoreIPC::encode(encoder, printSettings.get());
-    CoreIPC::encode(encoder, pageSetup.get());
+    IPC::encode(encoder, printSettings.get());
+    IPC::encode(encoder, pageSetup.get());
      encoder.encodeEnum(printMode);
  #endif
  }
  
-bool PrintInfo::decode(CoreIPC::ArgumentDecoder& decoder, PrintInfo& info)
+bool PrintInfo::decode(IPC::ArgumentDecoder& decoder, PrintInfo& info)
  {
      if (!decoder.decode(info.pageSetupScaleFactor))
          return false;
@@ -66,9 +66,9 @@ bool PrintInfo::decode(CoreIPC::ArgumentDecoder& decoder, PrintInfo& info)
          return false;
  
  #if PLATFORM(GTK)
-    if (!CoreIPC::decode(decoder, info.printSettings))
+    if (!IPC::decode(decoder, info.printSettings))
          return false;
-    if (!CoreIPC::decode(decoder, info.pageSetup))
+    if (!IPC::decode(decoder, info.pageSetup))
          return false;
      if (!decoder.decodeEnum(info.printMode))
          return false;
diff --git a/Source/WebKit2/Shared/PrintInfo.h b/Source/WebKit2/Shared/PrintInfo.h

index 9d290eb..c037ccf 100644 (file)
--- a/Source/WebKit2/Shared/PrintInfo.h
+++ b/Source/WebKit2/Shared/PrintInfo.h
@@ -37,7 +37,7 @@ typedef struct _GtkPageSetup GtkPageSetup;
  class NSPrintInfo;
  #endif
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -67,8 +67,8 @@ struct PrintInfo {
      PrintMode printMode;
  #endif
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, PrintInfo&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, PrintInfo&);
  };
  
  }
diff --git a/Source/WebKit2/Shared/SandboxExtension.h b/Source/WebKit2/Shared/SandboxExtension.h

index 2d96c27..06c6873 100644 (file)
--- a/Source/WebKit2/Shared/SandboxExtension.h
+++ b/Source/WebKit2/Shared/SandboxExtension.h
@@ -36,7 +36,7 @@
  typedef struct __WKSandboxExtension* WKSandboxExtensionRef;
  #endif
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentEncoder;
      class ArgumentDecoder;
  }
@@ -57,8 +57,8 @@ public:
          Handle();
          ~Handle();
  
-        void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
+        void encode(IPC::ArgumentEncoder&) const;
+        static bool decode(IPC::ArgumentDecoder&, Handle&);
  
      private:
          friend class SandboxExtension;
@@ -77,8 +77,8 @@ public:
          Handle& operator[](size_t i);
          const Handle& operator[](size_t i) const;
          size_t size() const;
-        void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder&, HandleArray&);
+        void encode(IPC::ArgumentEncoder&) const;
+        static bool decode(IPC::ArgumentDecoder&, HandleArray&);
         
      private:
  #if ENABLE(WEB_PROCESS_SANDBOX)
@@ -113,16 +113,16 @@ private:
  #if !ENABLE(WEB_PROCESS_SANDBOX)
  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 void SandboxExtension::Handle::encode(IPC::ArgumentEncoder&) const { }
+inline bool SandboxExtension::Handle::decode(IPC::ArgumentDecoder&, Handle&) { return true; }
  inline SandboxExtension::HandleArray::HandleArray() { }
  inline SandboxExtension::HandleArray::~HandleArray() { }
  inline void SandboxExtension::HandleArray::allocate(size_t) { }
  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 void SandboxExtension::HandleArray::encode(IPC::ArgumentEncoder&) const { }
+inline bool SandboxExtension::HandleArray::decode(IPC::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&) { }
diff --git a/Source/WebKit2/Shared/SecurityOriginData.cpp b/Source/WebKit2/Shared/SecurityOriginData.cpp

index dbf32fa..b6b4a9a 100644 (file)
--- a/Source/WebKit2/Shared/SecurityOriginData.cpp
+++ b/Source/WebKit2/Shared/SecurityOriginData.cpp
@@ -51,14 +51,14 @@ PassRefPtr<SecurityOrigin> SecurityOriginData::securityOrigin() const
      return SecurityOrigin::create(protocol, host, port);
  }
  
-void SecurityOriginData::encode(CoreIPC::ArgumentEncoder& encoder) const
+void SecurityOriginData::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << protocol;
      encoder << host;
      encoder << port;
  }
  
-bool SecurityOriginData::decode(CoreIPC::ArgumentDecoder& decoder, SecurityOriginData& securityOriginData)
+bool SecurityOriginData::decode(IPC::ArgumentDecoder& decoder, SecurityOriginData& securityOriginData)
  {
      if (!decoder.decode(securityOriginData.protocol))
          return false;
diff --git a/Source/WebKit2/Shared/SecurityOriginData.h b/Source/WebKit2/Shared/SecurityOriginData.h

index 2d4169c..96404e5 100644 (file)
--- a/Source/WebKit2/Shared/SecurityOriginData.h
+++ b/Source/WebKit2/Shared/SecurityOriginData.h
@@ -30,7 +30,7 @@
  #include "GenericCallback.h"
  #include <wtf/text/WTFString.h>
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -43,8 +43,8 @@ struct SecurityOriginData {
      static SecurityOriginData fromSecurityOrigin(const WebCore::SecurityOrigin*);
      PassRefPtr<WebCore::SecurityOrigin> securityOrigin() const;
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, SecurityOriginData&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, SecurityOriginData&);
  
      // FIXME <rdar://9018386>: We should be sending more state across the wire than just the protocol,
      // host, and port.
diff --git a/Source/WebKit2/Shared/SessionState.cpp b/Source/WebKit2/Shared/SessionState.cpp

index 9b36761..7ccbdc5 100644 (file)
--- a/Source/WebKit2/Shared/SessionState.cpp
+++ b/Source/WebKit2/Shared/SessionState.cpp
@@ -27,7 +27,7 @@
  #include "SessionState.h"
  #include "WebCoreArgumentCoders.h"
  
-namespace CoreIPC {
+namespace IPC {
  
  // This assumes that when we encode a RefPtr we want to encode the object it points to and it is never null.
  template<typename T> struct ArgumentCoder<RefPtr<T>> {
@@ -43,7 +43,7 @@ template<typename T> struct ArgumentCoder<RefPtr<T>> {
      }
  };
  
-} // namespace CoreIPC
+} // namespace IPC
  
  namespace WebKit {
  
@@ -65,13 +65,13 @@ bool SessionState::isEmpty() const
      return m_list.isEmpty();
  }
      
-void SessionState::encode(CoreIPC::ArgumentEncoder& encoder) const
+void SessionState::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_list;
      encoder << m_currentIndex;
  }
  
-bool SessionState::decode(CoreIPC::ArgumentDecoder& decoder, SessionState& state)
+bool SessionState::decode(IPC::ArgumentDecoder& decoder, SessionState& state)
  {
      if (!decoder.decode(state.m_list))
          return false;
diff --git a/Source/WebKit2/Shared/SessionState.h b/Source/WebKit2/Shared/SessionState.h

index 54b7186..ef82755 100644 (file)
--- a/Source/WebKit2/Shared/SessionState.h
+++ b/Source/WebKit2/Shared/SessionState.h
@@ -28,7 +28,7 @@
  
  #include "WebBackForwardListItem.h"
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -45,8 +45,8 @@ public:
  
      bool isEmpty() const;
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, SessionState&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, SessionState&);
  
  private:
      BackForwardListItemVector m_list;
diff --git a/Source/WebKit2/Shared/ShareableBitmap.cpp b/Source/WebKit2/Shared/ShareableBitmap.cpp

index 0f06c86..1971100 100644 (file)
--- a/Source/WebKit2/Shared/ShareableBitmap.cpp
+++ b/Source/WebKit2/Shared/ShareableBitmap.cpp
@@ -39,14 +39,14 @@ ShareableBitmap::Handle::Handle()
  {
  }
  
-void ShareableBitmap::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
+void ShareableBitmap::Handle::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_handle;
      encoder << m_size;
      encoder << m_flags;
  }
  
-bool ShareableBitmap::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
+bool ShareableBitmap::Handle::decode(IPC::ArgumentDecoder& decoder, Handle& handle)
  {
      if (!decoder.decode(handle.m_handle))
          return false;
diff --git a/Source/WebKit2/Shared/ShareableBitmap.h b/Source/WebKit2/Shared/ShareableBitmap.h

index 3a5d3bd..47161f0 100644 (file)
--- a/Source/WebKit2/Shared/ShareableBitmap.h
+++ b/Source/WebKit2/Shared/ShareableBitmap.h
@@ -63,8 +63,8 @@ public:
  
          bool isNull() const { return m_handle.isNull(); }
  
-        void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
+        void encode(IPC::ArgumentEncoder&) const;
+        static bool decode(IPC::ArgumentDecoder&, Handle&);
  
      private:
          friend class ShareableBitmap;
diff --git a/Source/WebKit2/Shared/ShareableResource.cpp b/Source/WebKit2/Shared/ShareableResource.cpp

index 1c6208f..1658fcb 100644 (file)
--- a/Source/WebKit2/Shared/ShareableResource.cpp
+++ b/Source/WebKit2/Shared/ShareableResource.cpp
@@ -39,14 +39,14 @@ ShareableResource::Handle::Handle()
  {
  }
  
-void ShareableResource::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
+void ShareableResource::Handle::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << m_handle;
      encoder << m_offset;
      encoder << m_size;
  }
  
-bool ShareableResource::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
+bool ShareableResource::Handle::decode(IPC::ArgumentDecoder& decoder, Handle& handle)
  {
      if (!decoder.decode(handle.m_handle))
          return false;
diff --git a/Source/WebKit2/Shared/ShareableResource.h b/Source/WebKit2/Shared/ShareableResource.h

index 6f681dd..8f4993f 100644 (file)
--- a/Source/WebKit2/Shared/ShareableResource.h
+++ b/Source/WebKit2/Shared/ShareableResource.h
@@ -51,8 +51,8 @@ public:
          bool isNull() const { return m_handle.isNull(); }
          unsigned size() const { return m_size; }
  
-        void encode(CoreIPC::ArgumentEncoder&) const;
-        static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
+        void encode(IPC::ArgumentEncoder&) const;
+        static bool decode(IPC::ArgumentDecoder&, Handle&);
  
          PassRefPtr<WebCore::SharedBuffer> tryWrapInSharedBuffer() const;
  
diff --git a/Source/WebKit2/Shared/StatisticsData.cpp b/Source/WebKit2/Shared/StatisticsData.cpp

index 24a85d3..6199e8c 100644 (file)
--- a/Source/WebKit2/Shared/StatisticsData.cpp
+++ b/Source/WebKit2/Shared/StatisticsData.cpp
@@ -30,7 +30,7 @@
  
  namespace WebKit {
  
-void StatisticsData::encode(CoreIPC::ArgumentEncoder& encoder) const
+void StatisticsData::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << statisticsNumbers;
      encoder << javaScriptProtectedObjectTypeCounts;
@@ -38,7 +38,7 @@ void StatisticsData::encode(CoreIPC::ArgumentEncoder& encoder) const
      encoder << webCoreCacheStatistics;
  }
  
-bool StatisticsData::decode(CoreIPC::ArgumentDecoder& decoder, StatisticsData& statisticsData)
+bool StatisticsData::decode(IPC::ArgumentDecoder& decoder, StatisticsData& statisticsData)
  {
      if (!decoder.decode(statisticsData.statisticsNumbers))
          return false;
diff --git a/Source/WebKit2/Shared/StatisticsData.h b/Source/WebKit2/Shared/StatisticsData.h

index 1dbfe2a..1494b2a 100644 (file)
--- a/Source/WebKit2/Shared/StatisticsData.h
+++ b/Source/WebKit2/Shared/StatisticsData.h
@@ -36,8 +36,8 @@
  namespace WebKit {
  
  struct StatisticsData {
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, StatisticsData&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, StatisticsData&);
      
      HashMap<String, uint64_t> statisticsNumbers;
      HashMap<String, uint64_t> javaScriptProtectedObjectTypeCounts;
diff --git a/Source/WebKit2/Shared/TextCheckerState.h b/Source/WebKit2/Shared/TextCheckerState.h

index 3bb5332..0473032 100644 (file)
--- a/Source/WebKit2/Shared/TextCheckerState.h
+++ b/Source/WebKit2/Shared/TextCheckerState.h
@@ -45,7 +45,7 @@ struct TextCheckerState {
  
  } // namespace WebKit
  
-namespace CoreIPC {
+namespace IPC {
  template<> struct ArgumentCoder<WebKit::TextCheckerState> : SimpleArgumentCoder<WebKit::TextCheckerState> { };
  };
  
diff --git a/Source/WebKit2/Shared/UpdateInfo.cpp b/Source/WebKit2/Shared/UpdateInfo.cpp

index daf14e2..8a79857 100644 (file)
--- a/Source/WebKit2/Shared/UpdateInfo.cpp
+++ b/Source/WebKit2/Shared/UpdateInfo.cpp
@@ -30,7 +30,7 @@
  
  namespace WebKit {
  
-void UpdateInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
+void UpdateInfo::encode(IPC::ArgumentEncoder& encoder) const
  {
      encoder << viewSize;
      encoder << deviceScaleFactor;
@@ -43,7 +43,7 @@ void UpdateInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
      encoder << bitmapOffset;
  }
  
-bool UpdateInfo::decode(CoreIPC::ArgumentDecoder& decoder, UpdateInfo& result)
+bool UpdateInfo::decode(IPC::ArgumentDecoder& decoder, UpdateInfo& result)
  {
      if (!decoder.decode(result.viewSize))
          return false;
diff --git a/Source/WebKit2/Shared/UpdateInfo.h b/Source/WebKit2/Shared/UpdateInfo.h

index b3b9285..d4c110d 100644 (file)
--- a/Source/WebKit2/Shared/UpdateInfo.h
+++ b/Source/WebKit2/Shared/UpdateInfo.h
@@ -30,7 +30,7 @@
  #include <WebCore/IntRect.h>
  #include <wtf/Noncopyable.h>
  
-namespace CoreIPC {
+namespace IPC {
      class ArgumentDecoder;
      class ArgumentEncoder;
  }
@@ -43,8 +43,8 @@ class UpdateInfo {
  public:
      UpdateInfo() { }
  
-    void encode(CoreIPC::ArgumentEncoder&) const;
-    static bool decode(CoreIPC::ArgumentDecoder&, UpdateInfo&);
+    void encode(IPC::ArgumentEncoder&) const;
+    static bool decode(IPC::ArgumentDecoder&, UpdateInfo&);
  
      // The size of the web view.
      WebCore::IntSize viewSize;
diff --git a/Source/WebKit2/Shared/UserData.cpp b/Source/WebKit2/Shared/UserData.cpp

index ca1d1df..1cb366f 100644 (file)
--- a/Source/WebKit2/Shared/UserData.cpp
+++ b/Source/WebKit2/Shared/UserData.cpp
@@ -84,17 +84,17 @@ RefPtr<API::Object> UserData::transform(API::Object* object, const std::function
      return object;
  }
  
-void UserData::encode(CoreIPC::ArgumentEncoder& encoder) const
+void UserData::encode(IPC::ArgumentEncoder& encoder) const
  {
      encode(encoder, m_object.get());
  }
  
-bool UserData::decode(CoreIPC::ArgumentDecoder& decoder, UserData& userData)
+bool UserData::decode(IPC::ArgumentDecoder& decoder, UserData& userData)
  {
      return decode(decoder, userData.m_object);
  }
  
-void UserData::encode(CoreIPC::ArgumentEncoder& encoder, const API::Object* object) const
+void UserData::encode(IPC::ArgumentEncoder& encoder, const API::Object* object) const
  {
      if (!object) {
          encoder.encodeEnum(API::Object::Type::Null);
@@ -104,7 +104,7 @@ void UserData::encode(CoreIPC::ArgumentEncoder& encoder, const API::Object* obje
      encode(encoder, *object);
  }
  
-void UserData::encode(CoreIPC::ArgumentEncoder& encoder, const API::Object& object) const
+void UserData::encode(IPC::ArgumentEncoder& encoder, const API::Object& object) const
  {
      API::Object::Type type = object.type();
      encoder.encodeEnum(type);
@@ -192,7 +192,7 @@ void UserData::encode(CoreIPC::ArgumentEncoder& encoder, const API::Object& obje
      }
  }
  
-bool UserData::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
+bool UserData::decode(IPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
  {
      API::Object::Type type;
      if (!decoder.decodeEnum(type))
@@ -284,7 +284,7 @@ bool UserData::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& re
          break;
  
      case API::Object::Type::SerializedScriptValue: {
author	andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Mon, 30 Dec 2013 20:20:02 +0000 (20:20 +0000)
committer	andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Mon, 30 Dec 2013 20:20:02 +0000 (20:20 +0000)