/*

 * Copyright (C) 2009 Google 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:

 *

 *     * Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

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

 *     * Neither the name of Google Inc. nor the names of its

 * contributors may be used to endorse or promote products derived from

 * this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT

 * OWNER OR 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 "config.h"

#include "FrameLoaderClientImpl.h"

#include "Chrome.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "FormState.h"

#include "FrameLoader.h"

#include "FrameLoadRequest.h"

#include "HTTPParsers.h"

#include "HistoryItem.h"

#include "HitTestResult.h"

#include "HTMLAppletElement.h"

#include "HTMLFormElement.h"  // needed by FormState.h

#include "HTMLNames.h"

#include "MIMETypeRegistry.h"

#include "MouseEvent.h"

#include "Page.h"

#include "PlatformString.h"

#include "PluginData.h"

#include "PluginDataChromium.h"

#include "StringExtras.h"

#include "WebDataSourceImpl.h"

#include "WebDevToolsAgentPrivate.h"

#include "WebFormElement.h"

#include "WebFrameClient.h"

#include "WebFrameImpl.h"

#include "WebKit.h"

#include "WebKitClient.h"

#include "WebMimeRegistry.h"

#include "WebNode.h"

#include "WebPlugin.h"

#include "WebPluginContainerImpl.h"

#include "WebPluginLoadObserver.h"

#include "WebPluginParams.h"

#include "WebSecurityOrigin.h"

#include "WebURL.h"

#include "WebURLError.h"

#include "WebVector.h"

#include "WebViewClient.h"

#include "WebViewImpl.h"

#include "WindowFeatures.h"

#include "WrappedResourceRequest.h"

#include "WrappedResourceResponse.h"

#include <wtf/text/CString.h>

using namespace WebCore;

namespace WebKit {

// Domain for internal error codes.

static const char internalErrorDomain[] = "WebKit";

// An internal error code.  Used to note a policy change error resulting from

// dispatchDecidePolicyForMIMEType not passing the PolicyUse option.

enum {

    PolicyChangeError = -10000,

};

FrameLoaderClientImpl::FrameLoaderClientImpl(WebFrameImpl* frame)

    : m_webFrame(frame)

    , m_hasRepresentation(false)

    , m_sentInitialResponseToPlugin(false)

    , m_nextNavigationPolicy(WebNavigationPolicyIgnore)

{

}

FrameLoaderClientImpl::~FrameLoaderClientImpl()

{

}

void FrameLoaderClientImpl::frameLoaderDestroyed()

{

    // When the WebFrame was created, it had an extra reference given to it on

    // behalf of the Frame.  Since the WebFrame owns us, this extra ref also

    // serves to keep us alive until the FrameLoader is done with us.  The

    // FrameLoader calls this method when it's going away.  Therefore, we balance

    // out that extra reference, which may cause 'this' to be deleted.

    m_webFrame->closing();

    m_webFrame->deref();

}

void FrameLoaderClientImpl::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*)

{

    if (m_webFrame->client())

        m_webFrame->client()->didClearWindowObject(m_webFrame);

    WebViewImpl* webview = m_webFrame->viewImpl();

    if (webview->devToolsAgentPrivate())

        webview->devToolsAgentPrivate()->didClearWindowObject(m_webFrame);

}

void FrameLoaderClientImpl::documentElementAvailable()

{

    if (m_webFrame->client())

        m_webFrame->client()->didCreateDocumentElement(m_webFrame);

}

void FrameLoaderClientImpl::didCreateScriptContextForFrame()

{

    if (m_webFrame->client())

        m_webFrame->client()->didCreateScriptContext(m_webFrame);

}

void FrameLoaderClientImpl::didDestroyScriptContextForFrame()

{

    if (m_webFrame->client())

        m_webFrame->client()->didDestroyScriptContext(m_webFrame);

}

void FrameLoaderClientImpl::didCreateIsolatedScriptContext()

{

    if (m_webFrame->client())

        m_webFrame->client()->didCreateIsolatedScriptContext(m_webFrame);

}

void FrameLoaderClientImpl::didPerformFirstNavigation() const

{

}

void FrameLoaderClientImpl::registerForIconNotification(bool)

{

}

void FrameLoaderClientImpl::didChangeScrollOffset()

{

    if (m_webFrame->client())

        m_webFrame->client()->didChangeScrollOffset(m_webFrame);

}

bool FrameLoaderClientImpl::allowJavaScript(bool enabledPerSettings)

{

    if (m_webFrame->client())

        return m_webFrame->client()->allowScript(m_webFrame, enabledPerSettings);

    return enabledPerSettings;

}

bool FrameLoaderClientImpl::allowPlugins(bool enabledPerSettings)

{

    if (m_webFrame->client())

        return m_webFrame->client()->allowPlugins(m_webFrame, enabledPerSettings);

    return enabledPerSettings;

}

bool FrameLoaderClientImpl::allowImages(bool enabledPerSettings)

{

    if (m_webFrame->client())

        return m_webFrame->client()->allowImages(m_webFrame, enabledPerSettings);

    return enabledPerSettings;

}

void FrameLoaderClientImpl::didNotAllowScript()

{

    if (m_webFrame->client())

        m_webFrame->client()->didNotAllowScript(m_webFrame);

}

void FrameLoaderClientImpl::didNotAllowPlugins()

{

    if (m_webFrame->client())

        m_webFrame->client()->didNotAllowPlugins(m_webFrame);

}

bool FrameLoaderClientImpl::hasWebView() const

{

    return m_webFrame->viewImpl();

}

bool FrameLoaderClientImpl::hasFrameView() const

{

    // The Mac port has this notion of a WebFrameView, which seems to be

    // some wrapper around an NSView.  Since our equivalent is HWND, I guess

    // we have a "frameview" whenever we have the toplevel HWND.

    return m_webFrame->viewImpl();

}

void FrameLoaderClientImpl::makeDocumentView()

{

    m_webFrame->createFrameView();

}

void FrameLoaderClientImpl::makeRepresentation(DocumentLoader*)

{

    m_hasRepresentation = true;

}

void FrameLoaderClientImpl::forceLayout()

{

    // FIXME

}

void FrameLoaderClientImpl::forceLayoutForNonHTML()

{

    // FIXME

}

void FrameLoaderClientImpl::setCopiesOnScroll()

{

    // FIXME

}

void FrameLoaderClientImpl::detachedFromParent2()

{

    // Nothing to do here.

}

void FrameLoaderClientImpl::detachedFromParent3()

{

    // Close down the proxy.  The purpose of this change is to make the

    // call to ScriptController::clearWindowShell a no-op when called from

    // Frame::pageDestroyed.  Without this change, this call to clearWindowShell

    // will cause a crash.  If you remove/modify this, just ensure that you can

    // go to a page and then navigate to a new page without getting any asserts

    // or crashes.

    m_webFrame->frame()->script()->proxy()->clearForClose();

    // Stop communicating with the WebFrameClient at this point since we are no

    // longer associated with the Page.

    m_webFrame->setClient(0);

}

// This function is responsible for associating the |identifier| with a given

// subresource load.  The following functions that accept an |identifier| are

// called for each subresource, so they should not be dispatched to the

// WebFrame.

void FrameLoaderClientImpl::assignIdentifierToInitialRequest(

    unsigned long identifier, DocumentLoader* loader,

    const ResourceRequest& request)

{

    if (m_webFrame->client()) {

        WrappedResourceRequest webreq(request);

        m_webFrame->client()->assignIdentifierToRequest(

            m_webFrame, identifier, webreq);

    }

}

// If the request being loaded by |loader| is a frame, update the ResourceType.

// A subresource in this context is anything other than a frame --

// this includes images and xmlhttp requests.  It is important to note that a

// subresource is NOT limited to stuff loaded through the frame's subresource

// loader. Synchronous xmlhttp requests for example, do not go through the

// subresource loader, but we still label them as TargetIsSubResource.

//

// The important edge cases to consider when modifying this function are

// how synchronous resource loads are treated during load/unload threshold.

static void setTargetTypeFromLoader(ResourceRequest& request, DocumentLoader* loader)

{

    if (loader == loader->frameLoader()->provisionalDocumentLoader()) {

        ResourceRequest::TargetType type;

        if (loader->frameLoader()->isLoadingMainFrame())

            type = ResourceRequest::TargetIsMainFrame;

        else

            type = ResourceRequest::TargetIsSubframe;

        request.setTargetType(type);

    }

}

void FrameLoaderClientImpl::dispatchWillSendRequest(

    DocumentLoader* loader, unsigned long identifier, ResourceRequest& request,

    const ResourceResponse& redirectResponse)

{

    if (loader) {

        // We want to distinguish between a request for a document to be loaded into

        // the main frame, a sub-frame, or the sub-objects in that document.

        setTargetTypeFromLoader(request, loader);

        // Avoid repeating a form submission when navigating back or forward.

        if (loader == loader->frameLoader()->provisionalDocumentLoader()

            && request.httpMethod() == "POST"

            && isBackForwardLoadType(loader->frameLoader()->loadType()))

            request.setCachePolicy(ReturnCacheDataDontLoad);

    }

    // FrameLoader::loadEmptyDocumentSynchronously() creates an empty document

    // with no URL.  We don't like that, so we'll rename it to about:blank.

    if (request.url().isEmpty())

        request.setURL(KURL(ParsedURLString, "about:blank"));

    if (request.firstPartyForCookies().isEmpty())

        request.setFirstPartyForCookies(KURL(ParsedURLString, "about:blank"));

    // Give the WebFrameClient a crack at the request.

    if (m_webFrame->client()) {

        WrappedResourceRequest webreq(request);

        WrappedResourceResponse webresp(redirectResponse);

        m_webFrame->client()->willSendRequest(

            m_webFrame, identifier, webreq, webresp);

    }

}

bool FrameLoaderClientImpl::shouldUseCredentialStorage(

    DocumentLoader*, unsigned long identifier)

{

    // FIXME

    // Intended to pass through to a method on the resource load delegate.

    // If implemented, that method controls whether the browser should ask the

    // networking layer for a stored default credential for the page (say from

    // the Mac OS keychain). If the method returns false, the user should be

    // presented with an authentication challenge whether or not the networking

    // layer has a credential stored.

    // This returns true for backward compatibility: the ability to override the

    // system credential store is new. (Actually, not yet fully implemented in

    // WebKit, as of this writing.)

    return true;

}

void FrameLoaderClientImpl::dispatchDidReceiveAuthenticationChallenge(

    DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&)

{

    // FIXME

}

void FrameLoaderClientImpl::dispatchDidCancelAuthenticationChallenge(

    DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&)

{

    // FIXME

}

void FrameLoaderClientImpl::dispatchDidReceiveResponse(DocumentLoader* loader,

                                                       unsigned long identifier,

                                                       const ResourceResponse& response)

{

    if (m_webFrame->client()) {

        WrappedResourceResponse webresp(response);

        m_webFrame->client()->didReceiveResponse(m_webFrame, identifier, webresp);

    }

}

void FrameLoaderClientImpl::dispatchDidReceiveContentLength(

    DocumentLoader* loader,

    unsigned long identifier,

    int lengthReceived)

{

}

// Called when a particular resource load completes

void FrameLoaderClientImpl::dispatchDidFinishLoading(DocumentLoader* loader,

                                                    unsigned long identifier)

{

    if (m_webFrame->client())

        m_webFrame->client()->didFinishResourceLoad(m_webFrame, identifier);

}

void FrameLoaderClientImpl::dispatchDidFailLoading(DocumentLoader* loader,

                                                  unsigned long identifier,

                                                  const ResourceError& error)

{

    if (m_webFrame->client())

        m_webFrame->client()->didFailResourceLoad(m_webFrame, identifier, error);

}

void FrameLoaderClientImpl::dispatchDidFinishDocumentLoad()

{

    // A frame may be reused.  This call ensures we don't hold on to our password

    // listeners and their associated HTMLInputElements.

    m_webFrame->clearPasswordListeners();

    if (m_webFrame->client())

        m_webFrame->client()->didFinishDocumentLoad(m_webFrame);

}

bool FrameLoaderClientImpl::dispatchDidLoadResourceFromMemoryCache(

    DocumentLoader* loader,

    const ResourceRequest& request,

    const ResourceResponse& response,

    int length)

{

    if (m_webFrame->client()) {

        WrappedResourceRequest webreq(request);

        WrappedResourceResponse webresp(response);

        m_webFrame->client()->didLoadResourceFromMemoryCache(

            m_webFrame, webreq, webresp);

    }

    return false;  // Do not suppress remaining notifications

}

void FrameLoaderClientImpl::dispatchDidHandleOnloadEvents()

{

    if (m_webFrame->client())

        m_webFrame->client()->didHandleOnloadEvents(m_webFrame);

}

// Redirect Tracking

// =================

// We want to keep track of the chain of redirects that occur during page

// loading. There are two types of redirects, server redirects which are HTTP

// response codes, and client redirects which are document.location= and meta

// refreshes.

//

// This outlines the callbacks that we get in different redirect situations,

// and how each call modifies the redirect chain.

//

// Normal page load

// ----------------

//   dispatchDidStartProvisionalLoad() -> adds URL to the redirect list

//   dispatchDidCommitLoad()           -> DISPATCHES & clears list

//

// Server redirect (success)

// -------------------------

//   dispatchDidStartProvisionalLoad()                    -> adds source URL

//   dispatchDidReceiveServerRedirectForProvisionalLoad() -> adds dest URL

//   dispatchDidCommitLoad()                              -> DISPATCHES

//

// Client redirect (success)

// -------------------------

//   (on page)

//   dispatchWillPerformClientRedirect() -> saves expected redirect

//   dispatchDidStartProvisionalLoad()   -> appends redirect source (since

//                                          it matches the expected redirect)

//                                          and the current page as the dest)

//   dispatchDidCancelClientRedirect()   -> clears expected redirect

//   dispatchDidCommitLoad()             -> DISPATCHES

//

// Client redirect (cancelled)

// (e.g meta-refresh trumped by manual doc.location change, or just cancelled

// because a link was clicked that requires the meta refresh to be rescheduled

// (the SOURCE URL may have changed).

// ---------------------------

//   dispatchDidCancelClientRedirect()                 -> clears expected redirect

//   dispatchDidStartProvisionalLoad()                 -> adds only URL to redirect list

//   dispatchDidCommitLoad()                           -> DISPATCHES & clears list

//   rescheduled ? dispatchWillPerformClientRedirect() -> saves expected redirect

//               : nothing

// Client redirect (failure)

// -------------------------

//   (on page)

//   dispatchWillPerformClientRedirect() -> saves expected redirect

//   dispatchDidStartProvisionalLoad()   -> appends redirect source (since

//                                          it matches the expected redirect)

//                                          and the current page as the dest)

//   dispatchDidCancelClientRedirect()

//   dispatchDidFailProvisionalLoad()

//

// Load 1 -> Server redirect to 2 -> client redirect to 3 -> server redirect to 4

// ------------------------------------------------------------------------------

//   dispatchDidStartProvisionalLoad()                    -> adds source URL 1

//   dispatchDidReceiveServerRedirectForProvisionalLoad() -> adds dest URL 2

//   dispatchDidCommitLoad()                              -> DISPATCHES 1+2

//    -- begin client redirect and NEW DATA SOURCE

//   dispatchWillPerformClientRedirect()                  -> saves expected redirect

//   dispatchDidStartProvisionalLoad()                    -> appends URL 2 and URL 3

//   dispatchDidReceiveServerRedirectForProvisionalLoad() -> appends destination URL 4

//   dispatchDidCancelClientRedirect()                    -> clears expected redirect

//   dispatchDidCommitLoad()                              -> DISPATCHES

//

// Interesting case with multiple location changes involving anchors.

// Load page 1 containing future client-redirect (back to 1, e.g meta refresh) > Click

// on a link back to the same page (i.e an anchor href) >

// client-redirect finally fires (with new source, set to 1#anchor)

// -----------------------------------------------------------------------------

//   dispatchWillPerformClientRedirect(non-zero 'interval' param) -> saves expected redirect

//   -- click on anchor href

//   dispatchDidCancelClientRedirect()                            -> clears expected redirect

//   dispatchDidStartProvisionalLoad()                            -> adds 1#anchor source

//   dispatchDidCommitLoad()                                      -> DISPATCHES 1#anchor

//   dispatchWillPerformClientRedirect()                          -> saves exp. source (1#anchor)

//   -- redirect timer fires

//   dispatchDidStartProvisionalLoad()                            -> appends 1#anchor (src) and 1 (dest)

//   dispatchDidCancelClientRedirect()                            -> clears expected redirect

//   dispatchDidCommitLoad()                                      -> DISPATCHES 1#anchor + 1

//

void FrameLoaderClientImpl::dispatchDidReceiveServerRedirectForProvisionalLoad()

{

    WebDataSourceImpl* ds = m_webFrame->provisionalDataSourceImpl();

    if (!ds) {

        // Got a server redirect when there is no provisional DS!

        ASSERT_NOT_REACHED();

        return;

    }

    // The server redirect may have been blocked.

    if (ds->request().isNull())

        return;

    // A provisional load should have started already, which should have put an

    // entry in our redirect chain.

    ASSERT(ds->hasRedirectChain());

    // The URL of the destination is on the provisional data source. We also need

    // to update the redirect chain to account for this addition (we do this

    // before the callback so the callback can look at the redirect chain to see

    // what happened).

    ds->appendRedirect(ds->request().url());

    if (m_webFrame->client())

        m_webFrame->client()->didReceiveServerRedirectForProvisionalLoad(m_webFrame);

}

// Called on both success and failure of a client redirect.

void FrameLoaderClientImpl::dispatchDidCancelClientRedirect()

{

    // No longer expecting a client redirect.

    if (m_webFrame->client()) {

        m_expectedClientRedirectSrc = KURL();

        m_expectedClientRedirectDest = KURL();