/*

 * 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;