diff -r 000000000000 -r 4f2f89ce4247 WebKit2/UIProcess/WebPageProxy.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WebKit2/UIProcess/WebPageProxy.cpp	Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,1006 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "WebPageProxy.h"
+
+#include "DrawingAreaProxy.h"
+#include "MessageID.h"
+#include "PageClient.h"
+#include "WebBackForwardList.h"
+#include "WebBackForwardListItem.h"
+#include "WebContext.h"
+#include "WebCoreArgumentCoders.h"
+#include "WebEvent.h"
+#include "WebNavigationDataStore.h"
+#include "WebPageMessageKinds.h"
+#include "WebPageNamespace.h"
+#include "WebPageProxyMessageKinds.h"
+#include "WebPreferences.h"
+#include "WebProcessManager.h"
+#include "WebProcessMessageKinds.h"
+#include "WebProcessProxy.h"
+
+#include "WKContextPrivate.h"
+#include <stdio.h>
+
+#ifndef NDEBUG
+#include <wtf/RefCountedLeakCounter.h>
+#endif
+
+using namespace WebCore;
+
+namespace WebKit {
+
+#ifndef NDEBUG
+static WTF::RefCountedLeakCounter webPageProxyCounter("WebPageProxy");
+#endif
+
+PassRefPtr<WebPageProxy> WebPageProxy::create(WebPageNamespace* pageNamespace, uint64_t pageID)
+{
+    return adoptRef(new WebPageProxy(pageNamespace, pageID));
+}
+
+WebPageProxy::WebPageProxy(WebPageNamespace* pageNamespace, uint64_t pageID)
+    : m_pageClient(0)
+    , m_pageNamespace(pageNamespace)
+    , m_mainFrame(0)
+    , m_estimatedProgress(0.0)
+    , m_isInWindow(false)
+    , m_backForwardList(WebBackForwardList::create(this))
+    , m_valid(true)
+    , m_closed(false)
+    , m_pageID(pageID)
+{
+#ifndef NDEBUG
+    webPageProxyCounter.increment();
+#endif
+}
+
+WebPageProxy::~WebPageProxy()
+{
+#ifndef NDEBUG
+    webPageProxyCounter.decrement();
+#endif
+}
+
+WebProcessProxy* WebPageProxy::process() const
+{
+    return m_pageNamespace->process();
+}
+
+bool WebPageProxy::isValid()
+{
+    return m_valid;
+}
+
+void WebPageProxy::setPageClient(PageClient* pageClient)
+{
+#if PLATFORM(WIN)
+    m_pageClient = pageClient;
+#else
+    m_pageClient.set(pageClient);
+#endif
+}
+
+void WebPageProxy::setDrawingArea(PassOwnPtr<DrawingAreaProxy> drawingArea)
+{
+    if (drawingArea == m_drawingArea)
+        return;
+
+    m_drawingArea = drawingArea;
+}
+
+void WebPageProxy::initializeLoaderClient(WKPageLoaderClient* loadClient)
+{
+    m_loaderClient.initialize(loadClient);
+}
+
+void WebPageProxy::initializePolicyClient(WKPagePolicyClient* policyClient)
+{
+    m_policyClient.initialize(policyClient);
+}
+
+void WebPageProxy::initializeUIClient(WKPageUIClient* client)
+{
+    m_uiClient.initialize(client);
+}
+
+void WebPageProxy::initializeHistoryClient(WKPageHistoryClient* client)
+{
+    m_historyClient.initialize(client);
+}
+
+void WebPageProxy::revive()
+{
+    m_valid = true;
+    m_pageNamespace->reviveIfNecessary();
+    m_pageNamespace->process()->addExistingWebPage(this, m_pageID);
+
+    processDidRevive();
+}
+
+void WebPageProxy::initializeWebPage(const IntSize& size, PassOwnPtr<DrawingAreaProxy> drawingArea)
+{
+    if (!isValid()) {
+        puts("initializeWebPage called with a dead WebProcess");
+        revive();
+        return;
+    }
+
+    m_drawingArea = drawingArea;
+    process()->send(WebProcessMessage::Create, m_pageID, CoreIPC::In(size, pageNamespace()->context()->preferences()->store(), *(m_drawingArea.get())));
+}
+
+void WebPageProxy::reinitializeWebPage(const WebCore::IntSize& size)
+{
+    if (!isValid())
+        return;
+
+    ASSERT(m_drawingArea);
+    process()->send(WebProcessMessage::Create, m_pageID, CoreIPC::In(size, pageNamespace()->context()->preferences()->store(), *(m_drawingArea.get())));
+}
+
+void WebPageProxy::close()
+{
+    if (!isValid())
+        return;
+
+    m_closed = true;
+
+    Vector<RefPtr<WebFrameProxy> > frames;
+    copyValuesToVector(m_frameMap, frames);
+    for (size_t i = 0, size = frames.size(); i < size; ++i)
+        frames[i]->disconnect();
+    m_frameMap.clear();
+    m_mainFrame = 0;
+
+    m_pageTitle = String();
+    m_toolTip = String();
+
+    Vector<RefPtr<ScriptReturnValueCallback> > scriptReturnValueCallbacks;
+    copyValuesToVector(m_scriptReturnValueCallbacks, scriptReturnValueCallbacks);
+    for (size_t i = 0, size = scriptReturnValueCallbacks.size(); i < size; ++i)
+        scriptReturnValueCallbacks[i]->invalidate();
+    m_scriptReturnValueCallbacks.clear();
+
+    Vector<RefPtr<RenderTreeExternalRepresentationCallback> > renderTreeExternalRepresentationCallbacks;
+    copyValuesToVector(m_renderTreeExternalRepresentationCallbacks, renderTreeExternalRepresentationCallbacks);
+    for (size_t i = 0, size = renderTreeExternalRepresentationCallbacks.size(); i < size; ++i)
+        renderTreeExternalRepresentationCallbacks[i]->invalidate();
+    m_renderTreeExternalRepresentationCallbacks.clear();
+
+    m_estimatedProgress = 0.0;
+    
+    m_loaderClient.initialize(0);
+    m_policyClient.initialize(0);
+    m_uiClient.initialize(0);
+
+    m_drawingArea.clear();
+
+    process()->send(WebPageMessage::Close, m_pageID, CoreIPC::In());
+    process()->removeWebPage(m_pageID);
+}
+
+bool WebPageProxy::tryClose()
+{
+    if (!isValid())
+        return true;
+
+    process()->send(WebPageMessage::TryClose, m_pageID, CoreIPC::In());
+    return false;
+}
+
+void WebPageProxy::loadURL(const String& url)
+{
+    if (!isValid()) {
+        puts("loadURL called with a dead WebProcess");
+        revive();
+    }
+    process()->send(WebPageMessage::LoadURL, m_pageID, CoreIPC::In(url));
+}
+
+void WebPageProxy::stopLoading()
+{
+    if (!isValid())
+        return;
+    process()->send(WebPageMessage::StopLoading, m_pageID, CoreIPC::In());
+}
+
+void WebPageProxy::reload(bool reloadFromOrigin)
+{
+    if (!isValid())
+        return;
+    process()->send(WebPageMessage::Reload, m_pageID, CoreIPC::In(reloadFromOrigin));
+}
+
+void WebPageProxy::goForward()
+{
+    if (!isValid())
+        return;
+
+    if (!canGoForward())
+        return;
+
+    process()->send(WebPageMessage::GoForward, m_pageID, CoreIPC::In(m_backForwardList->forwardItem()->itemID()));
+}
+
+bool WebPageProxy::canGoForward() const
+{
+    return m_backForwardList->forwardItem();
+}
+
+void WebPageProxy::goBack()
+{
+    if (!isValid())
+        return;
+
+    if (!canGoBack())
+        return;
+
+    process()->send(WebPageMessage::GoBack, m_pageID, CoreIPC::In(m_backForwardList->backItem()->itemID()));
+}
+
+bool WebPageProxy::canGoBack() const
+{
+    return m_backForwardList->backItem();
+}
+
+void WebPageProxy::goToBackForwardItem(WebBackForwardListItem* item)
+{
+    if (!isValid())
+        return;
+
+    process()->send(WebPageMessage::GoToBackForwardItem, m_pageID, CoreIPC::In(item->itemID()));
+}
+
+void WebPageProxy::didChangeBackForwardList()
+{
+    m_loaderClient.didChangeBackForwardList(this);
+}
+
+void WebPageProxy::setFocused(bool isFocused)
+{
+    if (!isValid())
+        return;
+    process()->send(WebPageMessage::SetFocused, m_pageID, CoreIPC::In(isFocused));
+}
+
+void WebPageProxy::setActive(bool active)
+{
+    if (!isValid())
+        return;
+    process()->send(WebPageMessage::SetActive, m_pageID, CoreIPC::In(active));
+}
+
+void WebPageProxy::setIsInWindow(bool isInWindow)
+{
+    if (m_isInWindow == isInWindow)
+        return;
+    
+    m_isInWindow = isInWindow;
+    if (!isValid())
+        return;
+    process()->send(WebPageMessage::SetIsInWindow, m_pageID, CoreIPC::In(isInWindow));
+}
+    
+void WebPageProxy::mouseEvent(const WebMouseEvent& event)
+{
+    if (!isValid())
+        return;
+
+    // NOTE: This does not start the responsiveness timer because mouse move should not indicate interaction.
+    if (event.type() != WebEvent::MouseMove)
+        process()->responsivenessTimer()->start();
+    process()->send(WebPageMessage::MouseEvent, m_pageID, CoreIPC::In(event));
+}
+
+void WebPageProxy::wheelEvent(const WebWheelEvent& event)
+{
+    if (!isValid())
+        return;
+
+    process()->responsivenessTimer()->start();
+    process()->send(WebPageMessage::WheelEvent, m_pageID, CoreIPC::In(event));
+}
+
+void WebPageProxy::keyEvent(const WebKeyboardEvent& event)
+{
+    if (!isValid())
+        return;
+
+    process()->responsivenessTimer()->start();
+    process()->send(WebPageMessage::KeyEvent, m_pageID, CoreIPC::In(event));
+}
+
+void WebPageProxy::receivedPolicyDecision(WebCore::PolicyAction action, WebFrameProxy* frame, uint64_t listenerID)
+{
+    if (!isValid())
+        return;
+
+    process()->send(WebPageMessage::DidReceivePolicyDecision, m_pageID, CoreIPC::In(frame->frameID(), listenerID, (uint32_t)action));
+}
+
+void WebPageProxy::terminateProcess()
+{
+    if (!isValid())
+        return;
+
+    process()->terminate();
+}
+
+void WebPageProxy::runJavaScriptInMainFrame(const String& script, PassRefPtr<ScriptReturnValueCallback> prpCallback)
+{
+    RefPtr<ScriptReturnValueCallback> callback = prpCallback;
+    uint64_t callbackID = callback->callbackID();
+    m_scriptReturnValueCallbacks.set(callbackID, callback.get());
+    process()->send(WebPageMessage::RunJavaScriptInMainFrame, m_pageID, CoreIPC::In(script, callbackID));
+}
+
+void WebPageProxy::getRenderTreeExternalRepresentation(PassRefPtr<RenderTreeExternalRepresentationCallback> prpCallback)
+{
+    RefPtr<RenderTreeExternalRepresentationCallback> callback = prpCallback;
+    uint64_t callbackID = callback->callbackID();
+    m_renderTreeExternalRepresentationCallbacks.set(callbackID, callback.get());
+    process()->send(WebPageMessage::GetRenderTreeExternalRepresentation, m_pageID, callbackID);
+}
+
+void WebPageProxy::preferencesDidChange()
+{
+    if (!isValid())
+        return;
+
+    // FIXME: It probably makes more sense to send individual preference changes.
+    process()->send(WebPageMessage::PreferencesDidChange, m_pageID, CoreIPC::In(pageNamespace()->context()->preferences()->store()));
+}
+
+void WebPageProxy::getStatistics(WKContextStatistics* statistics)
+{
+    statistics->numberOfWKFrames += m_frameMap.size();
+}
+
+
+WebFrameProxy* WebPageProxy::webFrame(uint64_t frameID) const
+{
+    return m_frameMap.get(frameID).get();
+}
+
+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::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), static_cast<NavigationType>(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), static_cast<NavigationType>(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::SetCursor: {
+            Cursor cursor;
+            if (!arguments.decode(cursor))
+                return;
+            setCursor(cursor);
+            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;
+        }
+        case WebPageProxyMessage::BackForwardAddItem: {
+            uint64_t itemID;
+            if (!arguments.decode(CoreIPC::Out(itemID)))
+                return;
+            addItemToBackForwardList(process()->webBackForwardItem(itemID));
+            break;
+        }
+        case WebPageProxyMessage::BackForwardGoToItem: {
+            uint64_t itemID;
+            if (!arguments.decode(CoreIPC::Out(itemID)))
+                return;
+            goToItemInBackForwardList(process()->webBackForwardItem(itemID));
+            break;
+        }
+        default:
+            ASSERT_NOT_REACHED();
+            break;
+    }
+}
+
+void WebPageProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments, CoreIPC::ArgumentEncoder& reply)
+{
+    if (messageID.is<CoreIPC::MessageClassDrawingAreaProxy>()) {
+        m_drawingArea->didReceiveSyncMessage(connection, messageID, arguments, reply);
+        return;
+    }
+
+    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;
+        }
+
+        case WebPageProxyMessage::BackForwardCurrentItem: {
+            WebBackForwardListItem* currentItem = m_backForwardList->currentItem();
+            uint64_t currentItemID = currentItem ? currentItem->itemID() : 0;
+            reply.encode(CoreIPC::In(currentItemID));
+            break;
+        }
+        case WebPageProxyMessage::BackForwardItemAtIndex: {
+            int itemIndex;
+            if (!arguments.decode(CoreIPC::Out(itemIndex)))
+                return;
+
+            WebBackForwardListItem* item = m_backForwardList->itemAtIndex(itemIndex);
+            uint64_t itemID = item ? item->itemID() : 0;
+            reply.encode(CoreIPC::In(itemID));
+            break;
+        }
+        case WebPageProxyMessage::BackForwardBackListCount: {
+            int backListCount = m_backForwardList->backListCount();
+            reply.encode(CoreIPC::In(backListCount));
+            break;
+        }
+        case WebPageProxyMessage::BackForwardForwardListCount: {
+            int forwardListCount = m_backForwardList->forwardListCount();
+            reply.encode(CoreIPC::In(forwardListCount));
+            break;
+        }
+#if USE(ACCELERATED_COMPOSITING)
+        case WebPageProxyMessage::DidChangeAcceleratedCompositing: {
+            bool compositing;
+            if (!arguments.decode(CoreIPC::Out(compositing)))
+                return;
+
+            didChangeAcceleratedCompositing(compositing);
+            reply.encode(CoreIPC::In(static_cast<uint32_t>(drawingArea()->type())));
+            break;
+        }
+#endif // USE(ACCELERATED_COMPOSITING)
+
+        default:
+            ASSERT_NOT_REACHED();
+            break;
+    }
+}
+
+void WebPageProxy::didCreateMainFrame(uint64_t frameID)
+{
+    ASSERT(!m_mainFrame);
+    ASSERT(m_frameMap.isEmpty());
+
+    m_mainFrame = WebFrameProxy::create(this, frameID);
+    m_frameMap.set(frameID, m_mainFrame);
+}
+
+void WebPageProxy::didCreateSubFrame(uint64_t frameID)
+{
+    ASSERT(m_mainFrame);
+    ASSERT(!m_frameMap.isEmpty());
+    ASSERT(!m_frameMap.contains(frameID));
+
+    m_frameMap.set(frameID, WebFrameProxy::create(this, frameID));
+}
+
+void WebPageProxy::didStartProgress()
+{
+    m_estimatedProgress = 0.0;
+    
+    m_loaderClient.didStartProgress(this);
+}
+
+void WebPageProxy::didChangeProgress(double value)
+{
+    m_estimatedProgress = value;
+    
+    m_loaderClient.didChangeProgress(this);
+}
+
+void WebPageProxy::didFinishProgress()
+{
+    m_estimatedProgress = 1.0;
+
+    m_loaderClient.didFinishProgress(this);
+}
+
+void WebPageProxy::didStartProvisionalLoadForFrame(WebFrameProxy* frame, const String& url)
+{
+    frame->didStartProvisionalLoad(url);
+    m_loaderClient.didStartProvisionalLoadForFrame(this, frame);
+}
+
+void WebPageProxy::didReceiveServerRedirectForProvisionalLoadForFrame(WebFrameProxy* frame)
+{
+    m_loaderClient.didReceiveServerRedirectForProvisionalLoadForFrame(this, frame);
+}
+
+void WebPageProxy::didFailProvisionalLoadForFrame(WebFrameProxy* frame)
+{
+    m_loaderClient.didFailProvisionalLoadWithErrorForFrame(this, frame);
+}
+
+void WebPageProxy::didCommitLoadForFrame(WebFrameProxy* frame)
+{
+    frame->didCommitLoad();
+    m_loaderClient.didCommitLoadForFrame(this, frame);
+}
+
+void WebPageProxy::didFinishLoadForFrame(WebFrameProxy* frame)
+{
+    frame->didFinishLoad();
+    m_loaderClient.didFinishLoadForFrame(this, frame);
+}
+
+void WebPageProxy::didFailLoadForFrame(WebFrameProxy* frame)
+{
+    m_loaderClient.didFailLoadWithErrorForFrame(this, frame);
+}
+
+void WebPageProxy::didReceiveTitleForFrame(WebFrameProxy* frame, const String& title)
+{
+    frame->didReceiveTitle(title);
+
+    // Cache the title for the main frame in the page.
+    if (frame == m_mainFrame)
+        m_pageTitle = title;
+
+    m_loaderClient.didReceiveTitleForFrame(this, title.impl(), frame);
+}
+
+void WebPageProxy::didFirstLayoutForFrame(WebFrameProxy* frame)
+{
+    m_loaderClient.didFirstLayoutForFrame(this, frame);
+}
+
+void WebPageProxy::didFirstVisuallyNonEmptyLayoutForFrame(WebFrameProxy* frame)
+{
+    m_loaderClient.didFirstVisuallyNonEmptyLayoutForFrame(this, frame);
+}
+
+// PolicyClient
+
+void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy* frame, NavigationType navigationType, const String& url, uint64_t listenerID)
+{
+    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
+    if (!m_policyClient.decidePolicyForNavigationAction(this, navigationType, url, frame, listener.get()))
+        listener->use();
+}
+
+void WebPageProxy::decidePolicyForNewWindowAction(WebFrameProxy* frame, NavigationType navigationType, const String& url, uint64_t listenerID)
+{
+    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
+    if (!m_policyClient.decidePolicyForNewWindowAction(this, navigationType, url, frame, listener.get()))
+        listener->use();
+}
+
+void WebPageProxy::decidePolicyForMIMEType(WebFrameProxy* frame, const String& MIMEType, const String& url, uint64_t listenerID)
+{
+    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
+    if (!m_policyClient.decidePolicyForMIMEType(this, MIMEType, url, frame, listener.get()))
+        listener->use();
+}
+
+// UIClient
+WebPageProxy* WebPageProxy::createNewPage()
+{
+    return m_uiClient.createNewPage(this);
+}
+    
+void WebPageProxy::showPage()
+{
+    m_uiClient.showPage(this);
+}
+
+void WebPageProxy::closePage()
+{
+    m_uiClient.close(this);
+}
+
+void WebPageProxy::runJavaScriptAlert(WebFrameProxy* frame, const WebCore::String& alertText)
+{
+    m_uiClient.runJavaScriptAlert(this, alertText.impl(), frame);
+}
+
+
+// HistoryClient
+
+void WebPageProxy::didNavigateWithNavigationData(WebFrameProxy* frame, const WebNavigationDataStore& store) 
+{
+    m_historyClient.didNavigateWithNavigationData(this, store, frame);
+}
+
+void WebPageProxy::didPerformClientRedirect(WebFrameProxy* frame, const String& sourceURLString, const String& destinationURLString)
+{
+    m_historyClient.didPerformClientRedirect(this, sourceURLString, destinationURLString, frame);
+}
+
+void WebPageProxy::didPerformServerRedirect(WebFrameProxy* frame, const String& sourceURLString, const String& destinationURLString)
+{
+    m_historyClient.didPerformServerRedirect(this, sourceURLString, destinationURLString, frame);
+}
+
+void WebPageProxy::didUpdateHistoryTitle(WebFrameProxy* frame, const String& title, const String& url)
+{
+    m_historyClient.didUpdateHistoryTitle(this, title, url, frame);
+}
+
+// BackForwardList
+
+void WebPageProxy::addItemToBackForwardList(WebBackForwardListItem* item)
+{
+    m_backForwardList->addItem(item);
+}
+
+void WebPageProxy::goToItemInBackForwardList(WebBackForwardListItem* item)
+{
+    m_backForwardList->goToItem(item);
+}
+
+// Other
+
+void WebPageProxy::takeFocus(bool direction)
+{
+    m_pageClient->takeFocus(direction);
+}
+
+void WebPageProxy::setToolTip(const String& toolTip)
+{
+    String oldToolTip = m_toolTip;
+    m_toolTip = toolTip;
+    m_pageClient->toolTipChanged(oldToolTip, m_toolTip);
+}
+
+void WebPageProxy::setCursor(const WebCore::Cursor& cursor)
+{
+    m_pageClient->setCursor(cursor);
+}
+
+void WebPageProxy::didReceiveEvent(WebEvent::Type type)
+{
+    switch (type) {
+        case WebEvent::MouseMove:
+            break;
+
+        case WebEvent::MouseDown:
+        case WebEvent::MouseUp:
+        case WebEvent::Wheel:
+        case WebEvent::KeyDown:
+        case WebEvent::KeyUp:
+        case WebEvent::RawKeyDown:
+        case WebEvent::Char:
+            process()->responsivenessTimer()->stop();
+            break;
+    }
+}
+
+void WebPageProxy::didRunJavaScriptInMainFrame(const String& resultString, uint64_t callbackID)
+{
+    RefPtr<ScriptReturnValueCallback> callback = m_scriptReturnValueCallbacks.take(callbackID);
+    if (!callback) {
+        // FIXME: Log error or assert.
+        return;
+    }
+
+    callback->performCallbackWithReturnValue(resultString.impl());
+}
+
+void WebPageProxy::didGetRenderTreeExternalRepresentation(const String& resultString, uint64_t callbackID)
+{
+    RefPtr<RenderTreeExternalRepresentationCallback> callback = m_renderTreeExternalRepresentationCallbacks.take(callbackID);
+    if (!callback) {
+        // FIXME: Log error or assert.
+        return;
+    }
+
+    callback->performCallbackWithReturnValue(resultString.impl());
+}
+
+#if USE(ACCELERATED_COMPOSITING)
+void WebPageProxy::didChangeAcceleratedCompositing(bool compositing)
+{
+    if (compositing)
+        didEnterAcceleratedCompositing();
+    else
+        didLeaveAcceleratedCompositing();
+}
+#endif
+
+void WebPageProxy::processDidBecomeUnresponsive()
+{
+    m_loaderClient.didBecomeUnresponsive(this);
+}
+
+void WebPageProxy::processDidBecomeResponsive()
+{
+    m_loaderClient.didBecomeResponsive(this);
+}
+
+void WebPageProxy::processDidExit()
+{
+    ASSERT(m_pageClient);
+
+    m_valid = false;
+
+    if (m_mainFrame)
+        m_urlAtProcessExit = m_mainFrame->url();
+
+    Vector<RefPtr<WebFrameProxy> > frames;
+    copyValuesToVector(m_frameMap, frames);
+    for (size_t i = 0, size = frames.size(); i < size; ++i)
+        frames[i]->disconnect();
+    m_frameMap.clear();
+    m_mainFrame = 0;
+
+    m_pageTitle = String();
+    m_toolTip = String();
+
+    Vector<RefPtr<ScriptReturnValueCallback> > scriptReturnValueCallbacks;
+    copyValuesToVector(m_scriptReturnValueCallbacks, scriptReturnValueCallbacks);
+    for (size_t i = 0, size = scriptReturnValueCallbacks.size(); i < size; ++i)
+        scriptReturnValueCallbacks[i]->invalidate();
+    m_scriptReturnValueCallbacks.clear();
+
+    Vector<RefPtr<RenderTreeExternalRepresentationCallback> > renderTreeExternalRepresentationCallbacks;
+    copyValuesToVector(m_renderTreeExternalRepresentationCallbacks, renderTreeExternalRepresentationCallbacks);
+    for (size_t i = 0, size = renderTreeExternalRepresentationCallbacks.size(); i < size; ++i)
+        renderTreeExternalRepresentationCallbacks[i]->invalidate();
+    m_renderTreeExternalRepresentationCallbacks.clear();
+
+    m_estimatedProgress = 0.0;
+    
+    m_pageClient->processDidExit();
+}
+
+void WebPageProxy::processDidRevive()
+{
+    ASSERT(m_pageClient);
+    m_pageClient->processDidRevive();
+}
+
+#if USE(ACCELERATED_COMPOSITING)
+void WebPageProxy::didEnterAcceleratedCompositing()
+{
+    m_pageClient->pageDidEnterAcceleratedCompositing();
+}
+
+void WebPageProxy::didLeaveAcceleratedCompositing()
+{
+    m_pageClient->pageDidLeaveAcceleratedCompositing();
+}
+#endif // USE(ACCELERATED_COMPOSITING)
+
+} // namespace WebKit