bool NPIdentifierData::decode(CoreIPC::ArgumentDecoder& decoder, NPIdentifierData& result)
{
if (!decoder.decode(result.m_isString))
return false;
if (result.m_isString)
return decoder.decode(result.m_string);
return decoder.decode(result.m_number);
}
bool ShareableResource::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
{
if (!decoder.decode(handle.m_handle))
return false;
if (!decoder.decode(handle.m_offset))
return false;
if (!decoder.decode(handle.m_size))
return false;
return true;
}
bool Size::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
{
WKSize size;
if (!decoder.decode(size.width))
return false;
if (!decoder.decode(size.height))
return false;
result = Size::create(size);
return true;
}
bool Point::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
{
WKPoint point;
if (!decoder.decode(point.x))
return false;
if (!decoder.decode(point.y))
return false;
result = Point::create(point);
return true;
}
bool WebPreferencesStore::decode(CoreIPC::ArgumentDecoder& decoder, WebPreferencesStore& result)
{
if (!decoder.decode(result.m_stringValues))
return false;
if (!decoder.decode(result.m_boolValues))
return false;
if (!decoder.decode(result.m_uint32Values))
return false;
if (!decoder.decode(result.m_doubleValues))
return false;
if (!decoder.decode(result.m_floatValues))
return false;
return true;
}
bool WebGestureEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebGestureEvent& t)
{
if (!WebEvent::decode(decoder, t))
return false;
if (!decoder.decode(t.m_position))
return false;
if (!decoder.decode(t.m_globalPosition))
return false;
if (!decoder.decode(t.m_area))
return false;
if (!decoder.decode(t.m_delta))
return false;
return true;
}
bool UpdateChunk::decode(CoreIPC::ArgumentDecoder& decoder, UpdateChunk& chunk)
{
IntRect rect;
if (!decoder.decode(rect))
return false;
chunk.m_rect = rect;
CoreIPC::Attachment attachment;
if (!decoder.decode(attachment))
return false;
chunk.m_size = attachment.size();
chunk.m_data = reinterpret_cast<uint8_t*>(attachment.address());
return true;
}
bool Rect::decode(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& result)
{
WKRect rect;
if (!decoder.decode(rect.origin.x))
return false;
if (!decoder.decode(rect.origin.y))
return false;
if (!decoder.decode(rect.size.width))
return false;
if (!decoder.decode(rect.size.height))
return false;
result = Rect::create(rect);
return true;
}
void WebPageProxy::didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments, CoreIPC::ArgumentEncoder& reply)
{
switch (messageID.get<WebPageProxyMessage::Kind>()) {
case WebPageProxyMessage::CreateNewPage: {
WebPageProxy* newPage = createNewPage();
if (newPage) {
// FIXME: Pass the real size.
reply.encode(CoreIPC::In(newPage->pageID(), IntSize(100, 100),
newPage->pageNamespace()->context()->preferences()->store(),
*(newPage->m_drawingArea.get())));
} else {
// FIXME: We should encode a drawing area type here instead.
reply.encode(CoreIPC::In(static_cast<uint64_t>(0), IntSize(), WebPreferencesStore(), 0));
}
break;
}
case WebPageProxyMessage::RunJavaScriptAlert: {
uint64_t frameID;
String alertText;
if (!arguments.decode(CoreIPC::Out(frameID, alertText)))
return;
runJavaScriptAlert(webFrame(frameID), alertText);
break;
}
default:
ASSERT_NOT_REACHED();
break;
}
}
bool NetworkResourceLoadParameters::decode(CoreIPC::ArgumentDecoder& decoder, NetworkResourceLoadParameters& result)
{
if (!decoder.decode(result.m_identifier))
return false;
if (!decoder.decode(result.m_webPageID))
return false;
if (!decoder.decode(result.m_webFrameID))
return false;
if (!decoder.decode(result.m_request))
return false;
bool hasHTTPBody;
if (!decoder.decode(hasHTTPBody))
return false;
if (hasHTTPBody) {
CoreIPC::DataReference formData;
if (!decoder.decode(formData))
return false;
DecoderAdapter httpBodyDecoderAdapter(formData.data(), formData.size());
result.m_request.setHTTPBody(FormData::decode(httpBodyDecoderAdapter));
if (!decoder.decode(result.m_requestBodySandboxExtensions))
return false;
}
if (result.m_request.url().isLocalFile()) {
if (!decoder.decode(result.m_resourceSandboxExtension))
return false;
}
if (!decoder.decodeEnum(result.m_priority))
return false;
if (!decoder.decodeEnum(result.m_contentSniffingPolicy))
return false;
if (!decoder.decodeEnum(result.m_allowStoredCredentials))
return false;
if (!decoder.decode(result.m_inPrivateBrowsingMode))
return false;
if (!decoder.decode(result.m_shouldClearReferrerOnHTTPSToHTTPRedirect))
return false;
return true;
}
bool PlatformPopupMenuData::decode(CoreIPC::ArgumentDecoder& decoder, PlatformPopupMenuData& data)
{
#if PLATFORM(MAC)
if (!decoder.decode(data.fontInfo))
return false;
if (!decoder.decode(data.shouldPopOver))
return false;
#elif PLATFORM(QT)
if (!decoder.decode(data.multipleSelections))
return false;
#else
UNUSED_PARAM(decoder);
UNUSED_PARAM(data);
#endif
return true;
}
bool WebCoordinatedSurface::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
{
if (!decoder.decode(handle.m_size))
return false;
if (!decoder.decode(handle.m_flags))
return false;
#if USE(GRAPHICS_SURFACE)
if (!decoder.decode(handle.m_graphicsSurfaceToken))
return false;
if (handle.m_graphicsSurfaceToken.isValid())
return true;
#endif
if (!decoder.decode(handle.m_bitmapHandle))
return false;
return true;
}
bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
{
ASSERT(!handle.m_port);
ASSERT(!handle.m_size);
uint64_t size;
if (!decoder.decode(size))
return false;
CoreIPC::MachPort machPort;
if (!decoder.decode(machPort))
return false;
handle.m_size = size;
handle.m_port = machPort.port();
return true;
}
bool WebTouchEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebTouchEvent& result)
{
if (!WebEvent::decode(decoder, result))
return false;
if (!decoder.decode(result.m_touchPoints))
return false;
return true;
}
bool WebContextMenuItemData::decode(CoreIPC::ArgumentDecoder& decoder, WebContextMenuItemData& item)
{
WebCore::ContextMenuItemType type;
if (!decoder.decodeEnum(type))
return false;
WebCore::ContextMenuAction action;
if (!decoder.decodeEnum(action))
return false;
String title;
if (!decoder.decode(title))
return false;
bool checked;
if (!decoder.decode(checked))
return false;
bool enabled;
if (!decoder.decode(enabled))
return false;
Vector<WebContextMenuItemData> submenu;
if (!decoder.decode(submenu))
return false;
switch (type) {
case WebCore::ActionType:
case WebCore::SeparatorType:
case WebCore::CheckableActionType:
item = WebContextMenuItemData(type, action, title, enabled, checked);
break;
case WebCore::SubmenuType:
item = WebContextMenuItemData(action, title, enabled, submenu);
break;
default:
ASSERT_NOT_REACHED();
return false;
}
return true;
}
bool PrintInfo::decode(CoreIPC::ArgumentDecoder& decoder, PrintInfo& info)
{
if (!decoder.decode(info.pageSetupScaleFactor))
return false;
if (!decoder.decode(info.availablePaperWidth))
return false;
if (!decoder.decode(info.availablePaperHeight))
return false;
#if PLATFORM(GTK)
if (!CoreIPC::decode(decoder, info.printSettings))
return false;
if (!CoreIPC::decode(decoder, info.pageSetup))
return false;
if (!decoder.decodeEnum(info.printMode))
return false;
#endif
return true;
}
bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
{
ASSERT_ARG(handle, !handle.m_size);
ASSERT_ARG(handle, handle.isNull());
CoreIPC::Attachment attachment;
if (!decoder.decode(attachment))
return false;
handle.adoptFromAttachment(attachment.releaseFileDescriptor(), attachment.size());
return true;
}
bool Plugin::Parameters::decode(CoreIPC::ArgumentDecoder& decoder, Parameters& parameters)
{
String urlString;
if (!decoder.decode(urlString))
return false;
// FIXME: We can't assume that the url passed in here is valid.
parameters.url = KURL(ParsedURLString, urlString);
if (!decoder.decode(parameters.names))
return false;
if (!decoder.decode(parameters.values))
return false;
if (!decoder.decode(parameters.mimeType))
return false;
if (!decoder.decode(parameters.isFullFramePlugin))
return false;
if (!decoder.decode(parameters.shouldUseManualLoader))
return false;
#if PLATFORM(MAC)
if (!decoder.decodeEnum(parameters.layerHostingMode))
return false;
#endif
if (parameters.names.size() != parameters.values.size()) {
decoder.markInvalid();
return false;
}
return true;
}
bool WebHitTestResult::Data::decode(CoreIPC::ArgumentDecoder& decoder, WebHitTestResult::Data& hitTestResultData)
{
if (!decoder.decode(hitTestResultData.absoluteImageURL)
|| !decoder.decode(hitTestResultData.absolutePDFURL)
|| !decoder.decode(hitTestResultData.absoluteLinkURL)
|| !decoder.decode(hitTestResultData.absoluteMediaURL)
|| !decoder.decode(hitTestResultData.linkLabel)
|| !decoder.decode(hitTestResultData.linkTitle)
|| !decoder.decode(hitTestResultData.isContentEditable)
|| !decoder.decode(hitTestResultData.elementBoundingBox)
|| !decoder.decode(hitTestResultData.isScrollbar))
return false;
return true;
}
void ChunkedUpdateDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
{
switch (messageID.get<DrawingAreaProxyMessage::Kind>()) {
case DrawingAreaProxyMessage::Update: {
UpdateChunk updateChunk;
if (!arguments.decode(updateChunk))
return;
update(&updateChunk);
break;
}
case DrawingAreaProxyMessage::DidSetSize: {
UpdateChunk updateChunk;
if (!arguments.decode(CoreIPC::Out(updateChunk)))
return;
didSetSize(&updateChunk);
break;
}
default:
ASSERT_NOT_REACHED();
}
}
bool SecItemRequestData::decode(CoreIPC::ArgumentDecoder& decoder, SecItemRequestData& secItemRequestData)
{
if (!decoder.decodeEnum(secItemRequestData.m_type))
return false;
if (!CoreIPC::decode(decoder, secItemRequestData.m_queryDictionary))
return false;
bool expectAttributes;
if (!decoder.decode(expectAttributes))
return false;
if (expectAttributes && !CoreIPC::decode(decoder, secItemRequestData.m_attributesToMatch))
return false;
return true;
}
bool WebMouseEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebMouseEvent& result)
{
if (!WebEvent::decode(decoder, result))
return false;
if (!decoder.decode(result.m_button))
return false;
if (!decoder.decode(result.m_position))
return false;
if (!decoder.decode(result.m_globalPosition))
return false;
if (!decoder.decode(result.m_deltaX))
return false;
if (!decoder.decode(result.m_deltaY))
return false;
if (!decoder.decode(result.m_deltaZ))
return false;
if (!decoder.decode(result.m_clickCount))
return false;
return true;
}
bool WebWheelEvent::decode(CoreIPC::ArgumentDecoder& decoder, WebWheelEvent& t)
{
if (!WebEvent::decode(decoder, t))
return false;
if (!decoder.decode(t.m_position))
return false;
if (!decoder.decode(t.m_globalPosition))
return false;
if (!decoder.decode(t.m_delta))
return false;
if (!decoder.decode(t.m_wheelTicks))
return false;
if (!decoder.decode(t.m_granularity))
return false;
if (!decoder.decode(t.m_directionInvertedFromDevice))
return false;
#if PLATFORM(MAC)
if (!decoder.decode(t.m_phase))
return false;
if (!decoder.decode(t.m_momentumPhase))
return false;
if (!decoder.decode(t.m_hasPreciseScrollingDeltas))
return false;
if (!decoder.decode(t.m_scrollCount))
return false;
if (!decoder.decode(t.m_unacceleratedScrollingDelta))
return false;
#endif
return true;
}
void WebPage::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
{
if (messageID.is<CoreIPC::MessageClassDrawingArea>()) {
ASSERT(m_drawingArea);
m_drawingArea->didReceiveMessage(connection, messageID, arguments);
return;
}
switch (messageID.get<WebPageMessage::Kind>()) {
case WebPageMessage::SetActive: {
bool active;
if (!arguments.decode(active))
return;
setActive(active);
break;
}
case WebPageMessage::SetFocused: {
bool focused;
if (!arguments.decode(focused))
return;
setFocused(focused);
break;
}
case WebPageMessage::MouseEvent: {
WebMouseEvent event;
if (!arguments.decode(event))
return;
connection->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In((uint32_t)event.type()));
PlatformMouseEvent platformEvent = platform(event);
mouseEvent(platformEvent);
break;
}
case WebPageMessage::WheelEvent: {
WebWheelEvent event;
if (!arguments.decode(event))
return;
connection->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In((uint32_t)event.type()));
PlatformWheelEvent platformEvent = platform(event);
wheelEvent(platformEvent);
break;
}
case WebPageMessage::KeyEvent: {
WebKeyboardEvent event;
if (!arguments.decode(event))
return;
connection->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In((uint32_t)event.type()));
PlatformKeyboardEvent platformEvent = platform(event);
keyEvent(platformEvent);
break;
}
case WebPageMessage::LoadURL: {
String url;
if (!arguments.decode(url))
return;
loadURL(url);
break;
}
case WebPageMessage::StopLoading:
stopLoading();
break;
case WebPageMessage::Reload:
bool reloadFromOrigin;
if (!arguments.decode(CoreIPC::Out(reloadFromOrigin)))
return;
reload(reloadFromOrigin);
break;
case WebPageMessage::GoForward:
goForward();
break;
case WebPageMessage::GoBack:
goBack();
break;
case WebPageMessage::DidReceivePolicyDecision: {
uint64_t frameID;
uint64_t listenerID;
uint32_t policyAction;
if (!arguments.decode(CoreIPC::Out(frameID, listenerID, policyAction)))
return;
didReceivePolicyDecision(webFrame(frameID), listenerID, (WebCore::PolicyAction)policyAction);
break;
}
case WebPageMessage::RunJavaScriptInMainFrame: {
String script;
uint64_t callbackID;
if (!arguments.decode(CoreIPC::Out(script, callbackID)))
return;
runJavaScriptInMainFrame(script, callbackID);
break;
}
case WebPageMessage::GetRenderTreeExternalRepresentation: {
uint64_t callbackID;
if (!arguments.decode(callbackID))
return;
getRenderTreeExternalRepresentation(callbackID);
break;
}
case WebPageMessage::Close: {
close();
break;
}
case WebPageMessage::TryClose: {
tryClose();
break;
}
default:
ASSERT_NOT_REACHED();
break;
}
}
bool WebConnectionToUIProcess::decodeMessageBody(CoreIPC::ArgumentDecoder& decoder, RefPtr<API::Object>& messageBody)
{
InjectedBundleUserMessageDecoder messageBodyDecoder(messageBody);
return decoder.decode(messageBodyDecoder);
}
bool WebProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, WebProcessCreationParameters& parameters)
{
if (!decoder.decode(parameters.injectedBundlePath))
return false;
if (!decoder.decode(parameters.injectedBundlePathExtensionHandle))
return false;
if (!decoder.decode(parameters.applicationCacheDirectory))
return false;
if (!decoder.decode(parameters.applicationCacheDirectoryExtensionHandle))
return false;
if (!decoder.decode(parameters.databaseDirectory))
return false;
if (!decoder.decode(parameters.databaseDirectoryExtensionHandle))
return false;
if (!decoder.decode(parameters.localStorageDirectory))
return false;
if (!decoder.decode(parameters.localStorageDirectoryExtensionHandle))
return false;
if (!decoder.decode(parameters.diskCacheDirectory))
return false;
if (!decoder.decode(parameters.diskCacheDirectoryExtensionHandle))
return false;
if (!decoder.decode(parameters.cookieStorageDirectory))
return false;
if (!decoder.decode(parameters.cookieStorageDirectoryExtensionHandle))
return false;
if (!decoder.decode(parameters.shouldUseTestingNetworkSession))
return false;
if (!decoder.decode(parameters.urlSchemesRegistererdAsEmptyDocument))
return false;
if (!decoder.decode(parameters.urlSchemesRegisteredAsSecure))
return false;
if (!decoder.decode(parameters.urlSchemesForWhichDomainRelaxationIsForbidden))
return false;
if (!decoder.decode(parameters.urlSchemesRegisteredAsLocal))
return false;
if (!decoder.decode(parameters.urlSchemesRegisteredAsNoAccess))
return false;
if (!decoder.decode(parameters.urlSchemesRegisteredAsDisplayIsolated))
return false;
if (!decoder.decode(parameters.urlSchemesRegisteredAsCORSEnabled))
return false;
#if ENABLE(CUSTOM_PROTOCOLS)
if (!decoder.decode(parameters.urlSchemesRegisteredForCustomProtocols))
return false;
#endif
#if USE(SOUP)
if (!decoder.decode(parameters.urlSchemesRegistered))
return false;
if (!decoder.decode(parameters.cookiePersistentStoragePath))
return false;
if (!decoder.decode(parameters.cookiePersistentStorageType))
return false;
if (!decoder.decodeEnum(parameters.cookieAcceptPolicy))
return false;
if (!decoder.decode(parameters.ignoreTLSErrors))
return false;
#endif
if (!decoder.decodeEnum(parameters.cacheModel))
return false;
if (!decoder.decode(parameters.shouldTrackVisitedLinks))
return false;
if (!decoder.decode(parameters.shouldAlwaysUseComplexTextCodePath))
return false;
if (!decoder.decode(parameters.shouldUseFontSmoothing))
return false;
if (!decoder.decode(parameters.iconDatabaseEnabled))
return false;
if (!decoder.decode(parameters.terminationTimeout))
return false;
if (!decoder.decode(parameters.languages))
return false;
if (!decoder.decode(parameters.textCheckerState))
return false;
if (!decoder.decode(parameters.fullKeyboardAccessEnabled))
return false;
if (!decoder.decode(parameters.defaultRequestTimeoutInterval))
return false;
#if PLATFORM(MAC) || USE(CFNETWORK)
if (!decoder.decode(parameters.uiProcessBundleIdentifier))
return false;
#endif
#if PLATFORM(MAC)
if (!decoder.decode(parameters.presenterApplicationPid))
return false;
if (!decoder.decode(parameters.accessibilityEnhancedUserInterfaceEnabled))
return false;
if (!decoder.decode(parameters.nsURLCacheMemoryCapacity))
return false;
if (!decoder.decode(parameters.nsURLCacheDiskCapacity))
return false;
if (!decoder.decode(parameters.acceleratedCompositingPort))
return false;
if (!decoder.decode(parameters.uiProcessBundleResourcePath))
return false;
if (!decoder.decode(parameters.uiProcessBundleResourcePathExtensionHandle))
return false;
if (!decoder.decode(parameters.shouldForceScreenFontSubstitution))
return false;
if (!decoder.decode(parameters.shouldEnableKerningAndLigaturesByDefault))
return false;
#endif
#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
if (!decoder.decode(parameters.notificationPermissions))
return false;
#endif
#if ENABLE(NETWORK_PROCESS)
if (!decoder.decode(parameters.usesNetworkProcess))
return false;
#endif
if (!decoder.decode(parameters.plugInAutoStartOriginHashes))
return false;
if (!decoder.decode(parameters.plugInAutoStartOrigins))
return false;
return true;
}
void WebPageProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
{
if (messageID.is<CoreIPC::MessageClassDrawingAreaProxy>()) {
m_drawingArea->didReceiveMessage(connection, messageID, arguments);
return;
}
switch (messageID.get<WebPageProxyMessage::Kind>()) {
case WebPageProxyMessage::DidCreateMainFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didCreateMainFrame(frameID);
break;
}
case WebPageProxyMessage::DidCreateSubFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didCreateSubFrame(frameID);
break;
}
case WebPageProxyMessage::DidStartProvisionalLoadForFrame: {
uint64_t frameID;
String url;
if (!arguments.decode(CoreIPC::Out(frameID, url)))
return;
didStartProvisionalLoadForFrame(webFrame(frameID), url);
break;
}
case WebPageProxyMessage::DidReceiveServerRedirectForProvisionalLoadForFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didReceiveServerRedirectForProvisionalLoadForFrame(webFrame(frameID));
break;
}
case WebPageProxyMessage::DidFailProvisionalLoadForFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didFailProvisionalLoadForFrame(webFrame(frameID));
break;
}
case WebPageProxyMessage::DidCommitLoadForFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didCommitLoadForFrame(webFrame(frameID));
break;
}
case WebPageProxyMessage::DidFinishLoadForFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didFinishLoadForFrame(webFrame(frameID));
break;
}
case WebPageProxyMessage::DidFailLoadForFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didFailLoadForFrame(webFrame(frameID));
break;
}
case WebPageProxyMessage::DidReceiveTitleForFrame: {
uint64_t frameID;
String title;
if (!arguments.decode(CoreIPC::Out(frameID, title)))
return;
didReceiveTitleForFrame(webFrame(frameID), title);
break;
}
case WebPageProxyMessage::DidFirstLayoutForFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didFirstLayoutForFrame(webFrame(frameID));
break;
}
case WebPageProxyMessage::DidFirstVisuallyNonEmptyLayoutForFrame: {
uint64_t frameID;
if (!arguments.decode(frameID))
return;
didFirstVisuallyNonEmptyLayoutForFrame(webFrame(frameID));
break;
}
case WebPageProxyMessage::DidStartProgress:
didStartProgress();
break;
case WebPageProxyMessage::DidChangeProgress: {
double value;
if (!arguments.decode(value))
return;
didChangeProgress(value);
break;
}
case WebPageProxyMessage::DidFinishProgress:
didFinishProgress();
break;
case WebPageProxyMessage::DidReceiveEvent: {
uint32_t type;
if (!arguments.decode(type))
return;
didReceiveEvent((WebEvent::Type)type);
break;
}
case WebPageProxyMessage::TakeFocus: {
// FIXME: Use enum here.
bool direction;
if (!arguments.decode(direction))
return;
takeFocus(direction);
break;
}
case WebPageProxyMessage::DidChangeCanGoBack: {
bool canGoBack;
if (!arguments.decode(canGoBack))
return;
m_canGoBack = canGoBack;
break;
}
case WebPageProxyMessage::DidChangeCanGoForward: {
bool canGoForward;
if (!arguments.decode(canGoForward))
return;
m_canGoForward = canGoForward;
break;
}
case WebPageProxyMessage::DecidePolicyForNavigationAction: {
uint64_t frameID;
uint32_t navigationType;
String url;
uint64_t listenerID;
if (!arguments.decode(CoreIPC::Out(frameID, navigationType, url, listenerID)))
return;
decidePolicyForNavigationAction(webFrame(frameID), navigationType, url, listenerID);
break;
}
case WebPageProxyMessage::DecidePolicyForNewWindowAction: {
uint64_t frameID;
uint32_t navigationType;
String url;
uint64_t listenerID;
if (!arguments.decode(CoreIPC::Out(frameID, navigationType, url, listenerID)))
return;
decidePolicyForNewWindowAction(webFrame(frameID), navigationType, url, listenerID);
break;
}
case WebPageProxyMessage::DecidePolicyForMIMEType: {
uint64_t frameID;
String MIMEType;
String url;
uint64_t listenerID;
if (!arguments.decode(CoreIPC::Out(frameID, MIMEType, url, listenerID)))
return;
decidePolicyForMIMEType(webFrame(frameID), MIMEType, url, listenerID);
break;
}
case WebPageProxyMessage::DidRunJavaScriptInMainFrame: {
String resultString;
uint64_t callbackID;
if (!arguments.decode(CoreIPC::Out(resultString, callbackID)))
return;
didRunJavaScriptInMainFrame(resultString, callbackID);
break;
}
case WebPageProxyMessage::DidGetRenderTreeExternalRepresentation: {
String resultString;
uint64_t callbackID;
if (!arguments.decode(CoreIPC::Out(resultString, callbackID)))
return;
didGetRenderTreeExternalRepresentation(resultString, callbackID);
break;
}
case WebPageProxyMessage::SetToolTip: {
String toolTip;
if (!arguments.decode(toolTip))
return;
setToolTip(toolTip);
break;
}
case WebPageProxyMessage::ShowPage: {
showPage();
break;
}
case WebPageProxyMessage::ClosePage: {
closePage();
break;
}
case WebPageProxyMessage::DidNavigateWithNavigationData: {
WebNavigationDataStore store;
uint64_t frameID;
if (!arguments.decode(CoreIPC::Out(store, frameID)))
return;
didNavigateWithNavigationData(webFrame(frameID), store);
break;
}
case WebPageProxyMessage::DidPerformClientRedirect: {
String sourceURLString;
String destinationURLString;
uint64_t frameID;
if (!arguments.decode(CoreIPC::Out(sourceURLString, destinationURLString, frameID)))
return;
didPerformClientRedirect(webFrame(frameID), sourceURLString, destinationURLString);
break;
}
case WebPageProxyMessage::DidPerformServerRedirect: {
String sourceURLString;
String destinationURLString;
uint64_t frameID;
if (!arguments.decode(CoreIPC::Out(sourceURLString, destinationURLString, frameID)))
return;
didPerformServerRedirect(webFrame(frameID), sourceURLString, destinationURLString);
break;
}
case WebPageProxyMessage::DidUpdateHistoryTitle: {
String title;
String url;
uint64_t frameID;
if (!arguments.decode(CoreIPC::Out(title, url, frameID)))
return;
didUpdateHistoryTitle(webFrame(frameID), title, url);
break;
}
default:
ASSERT_NOT_REACHED();
break;
}
}
bool WebPageCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, WebPageCreationParameters& parameters)
{
if (!decoder.decode(parameters.viewSize))
return false;
if (!decoder.decode(parameters.isActive))
return false;
if (!decoder.decode(parameters.isFocused))
return false;
if (!decoder.decode(parameters.isVisible))
return false;
if (!decoder.decode(parameters.isInWindow))
return false;
if (!decoder.decode(parameters.store))
return false;
if (!decoder.decodeEnum(parameters.drawingAreaType))
return false;
if (!decoder.decode(parameters.pageGroupData))
return false;
if (!decoder.decode(parameters.drawsBackground))
return false;
if (!decoder.decode(parameters.drawsTransparentBackground))
return false;
if (!decoder.decode(parameters.underlayColor))
return false;
if (!decoder.decode(parameters.areMemoryCacheClientCallsEnabled))
return false;
if (!decoder.decode(parameters.useFixedLayout))
return false;
if (!decoder.decode(parameters.fixedLayoutSize))
return false;
if (!decoder.decodeEnum(parameters.paginationMode))
return false;
if (!decoder.decode(parameters.paginationBehavesLikeColumns))
return false;
if (!decoder.decode(parameters.pageLength))
return false;
if (!decoder.decode(parameters.gapBetweenPages))
return false;
if (!decoder.decode(parameters.userAgent))
return false;
if (!decoder.decode(parameters.sessionState))
return false;
if (!decoder.decode(parameters.highestUsedBackForwardItemID))
return false;
if (!decoder.decode(parameters.canRunBeforeUnloadConfirmPanel))
return false;
if (!decoder.decode(parameters.canRunModal))
return false;
if (!decoder.decode(parameters.deviceScaleFactor))
return false;
if (!decoder.decode(parameters.mediaVolume))
return false;
if (!decoder.decode(parameters.mayStartMediaWhenInWindow))
return false;
#if PLATFORM(MAC)
if (!decoder.decodeEnum(parameters.layerHostingMode))
return false;
if (!decoder.decode(parameters.colorSpace))
return false;
#endif
return true;
}
bool LayerTreeContext::decode(CoreIPC::ArgumentDecoder& decoder, LayerTreeContext& context)
{
return decoder.decode(context.coordinatedLayerID);
}
bool NetworkProcessCreationParameters::decode(CoreIPC::ArgumentDecoder& decoder, NetworkProcessCreationParameters& result)
{
if (!decoder.decode(result.privateBrowsingEnabled))
return false;
if (!decoder.decodeEnum(result.cacheModel))
return false;
if (!decoder.decode(result.diskCacheDirectory))
return false;
if (!decoder.decode(result.diskCacheDirectoryExtensionHandle))
return false;
if (!decoder.decode(result.shouldUseTestingNetworkSession))
return false;
#if PLATFORM(MAC)
if (!decoder.decode(result.parentProcessName))
return false;
if (!decoder.decode(result.uiProcessBundleIdentifier))
return false;
if (!decoder.decode(result.nsURLCacheMemoryCapacity))
return false;
if (!decoder.decode(result.nsURLCacheDiskCapacity))
return false;
#if ENABLE(CUSTOM_PROTOCOLS)
if (!decoder.decode(result.urlSchemesRegisteredForCustomProtocols))
return false;
#endif
if (!decoder.decode(result.httpProxy))
return false;
if (!decoder.decode(result.httpsProxy))
return false;
#endif
return true;
}