/*

 * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)

 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

 * Copyright (C) 2008 Alp Toker <alp@atoker.com>

 * Copyright (C) Research In Motion Limited 2009. 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. 

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") 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 APPLE 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 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 "config.h"

#include "FrameLoader.h"

#include "ApplicationCacheHost.h"

#include "Archive.h"

#include "ArchiveFactory.h"

#include "BackForwardList.h"

#include "BeforeUnloadEvent.h"

#include "Cache.h"

#include "CachedPage.h"

#include "Chrome.h"

#include "DOMImplementation.h"

#include "DOMWindow.h"

#include "DocLoader.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "Editor.h"

#include "EditorClient.h"

#include "Element.h"

#include "Event.h"

#include "EventNames.h"

#include "FloatRect.h"

#include "FormState.h"

#include "FormSubmission.h"

#include "Frame.h"

#include "FrameLoadRequest.h"

#include "FrameLoaderClient.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "HTMLAnchorElement.h"

#include "HTMLFormElement.h"

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

#include "HTMLMediaElement.h"

#endif

#include "HTMLNames.h"

#include "HTMLObjectElement.h"

#include "HTTPParsers.h"

#include "HistoryItem.h"

#include "IconDatabase.h"

#include "IconLoader.h"

#include "InspectorController.h"

#include "Logging.h"

#include "MIMETypeRegistry.h"

#include "MainResourceLoader.h"

#include "Page.h"

#include "PageCache.h"

#include "PageGroup.h"

#include "PageTransitionEvent.h"

#include "PlaceholderDocument.h"

#include "PluginData.h"

#include "PluginDatabase.h"

#include "PluginDocument.h"

#include "ProgressTracker.h"

#include "ResourceHandle.h"

#include "ResourceRequest.h"

#include "SchemeRegistry.h"

#include "ScriptController.h"

#include "ScriptSourceCode.h"

#include "ScriptString.h"

#include "ScriptValue.h"

#include "SecurityOrigin.h"

#include "SegmentedString.h"

#include "Settings.h"

#include "TextResourceDecoder.h"

#include "WindowFeatures.h"

#include "XMLDocumentParser.h"

#include <wtf/CurrentTime.h>

#include <wtf/StdLibExtras.h>

#include <wtf/text/CString.h>

#if ENABLE(SHARED_WORKERS)

#include "SharedWorkerRepository.h"

#endif

#if ENABLE(SVG)

#include "SVGDocument.h"

#include "SVGLocatable.h"

#include "SVGNames.h"

#include "SVGPreserveAspectRatio.h"

#include "SVGSVGElement.h"

#include "SVGViewElement.h"

#include "SVGViewSpec.h"

#endif

namespace WebCore {

using namespace HTMLNames;

#if ENABLE(SVG)

using namespace SVGNames;

#endif

#if ENABLE(XHTMLMP)

static const char defaultAcceptHeader[] = "application/xml,application/vnd.wap.xhtml+xml,application/xhtml+xml;profile='http://www.wapforum.org/xhtml',text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5";

#else

static const char defaultAcceptHeader[] = "application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5";

#endif

static double storedTimeOfLastCompletedLoad;

bool isBackForwardLoadType(FrameLoadType type)

{

    switch (type) {

        case FrameLoadTypeStandard:

        case FrameLoadTypeReload:

        case FrameLoadTypeReloadFromOrigin:

        case FrameLoadTypeSame:

        case FrameLoadTypeRedirectWithLockedBackForwardList:

        case FrameLoadTypeReplace:

            return false;

        case FrameLoadTypeBack:

        case FrameLoadTypeBackWMLDeckNotAccessible:

        case FrameLoadTypeForward:

        case FrameLoadTypeIndexedBackForward:

            return true;

    }

    ASSERT_NOT_REACHED();

    return false;

}

static int numRequests(Document* document)

{

    if (!document)

        return 0;

    return document->docLoader()->requestCount();

}

static inline bool canReferToParentFrameEncoding(const Frame* frame, const Frame* parentFrame) 

{

    return parentFrame && parentFrame->document()->securityOrigin()->canAccess(frame->document()->securityOrigin());

}

// This is not in the FrameLoader class to emphasize that it does not depend on

// private FrameLoader data, and to avoid increasing the number of public functions

// with access to private data.  Since only this .cpp file needs it, making it

// non-member lets us exclude it from the header file, thus keeping FrameLoader.h's

// API simpler.

//

// FIXME: isDocumentSandboxed should eventually replace isSandboxed.

static bool isDocumentSandboxed(Frame* frame, SandboxFlags mask)

{

    return frame->document() && frame->document()->securityOrigin()->isSandboxed(mask);

}

FrameLoader::FrameLoader(Frame* frame, FrameLoaderClient* client)

    : m_frame(frame)

    , m_client(client)

    , m_policyChecker(frame)

    , m_history(frame)

    , m_notifer(frame)

    , m_writer(frame)

    , m_subframeLoader(frame)

    , m_state(FrameStateCommittedPage)

    , m_loadType(FrameLoadTypeStandard)

    , m_delegateIsHandlingProvisionalLoadError(false)

    , m_quickRedirectComing(false)

    , m_sentRedirectNotification(false)

    , m_inStopAllLoaders(false)

    , m_isExecutingJavaScriptFormAction(false)

    , m_didCallImplicitClose(false)

    , m_wasUnloadEventEmitted(false)

    , m_pageDismissalEventBeingDispatched(false)

    , m_isComplete(false)

    , m_isLoadingMainResource(false)

    , m_needsClear(false)

    , m_checkTimer(this, &FrameLoader::checkTimerFired)

    , m_shouldCallCheckCompleted(false)

    , m_shouldCallCheckLoadComplete(false)

    , m_opener(0)

    , m_didPerformFirstNavigation(false)

    , m_loadingFromCachedPage(false)

    , m_suppressOpenerInNewFrame(false)

    , m_sandboxFlags(SandboxAll)

    , m_forcedSandboxFlags(SandboxNone)

#ifndef NDEBUG

    , m_didDispatchDidCommitLoad(false)

#endif

{

}

FrameLoader::~FrameLoader()

{

    setOpener(0);

    HashSet<Frame*>::iterator end = m_openedFrames.end();

    for (HashSet<Frame*>::iterator it = m_openedFrames.begin(); it != end; ++it)

        (*it)->loader()->m_opener = 0;

    m_client->frameLoaderDestroyed();

}

void FrameLoader::init()

{

    // Propagate sandbox attributes to this Frameloader and its descendants.

    // This needs to be done early, so that an initial document gets correct sandbox flags in its SecurityOrigin.

    updateSandboxFlags();

    // this somewhat odd set of steps is needed to give the frame an initial empty document

    m_stateMachine.advanceTo(FrameLoaderStateMachine::CreatingInitialEmptyDocument);

    setPolicyDocumentLoader(m_client->createDocumentLoader(ResourceRequest(KURL(ParsedURLString, "")), SubstituteData()).get());

    setProvisionalDocumentLoader(m_policyDocumentLoader.get());

    setState(FrameStateProvisional);

    m_provisionalDocumentLoader->setResponse(ResourceResponse(KURL(), "text/html", 0, String(), String()));

    m_provisionalDocumentLoader->finishedLoading();

    writer()->begin(KURL(), false);

    writer()->end();

    m_frame->document()->cancelParsing();

    m_stateMachine.advanceTo(FrameLoaderStateMachine::DisplayingInitialEmptyDocument);

    m_didCallImplicitClose = true;

}

void FrameLoader::setDefersLoading(bool defers)

{

    if (m_documentLoader)

        m_documentLoader->setDefersLoading(defers);

    if (m_provisionalDocumentLoader)

        m_provisionalDocumentLoader->setDefersLoading(defers);

    if (m_policyDocumentLoader)

        m_policyDocumentLoader->setDefersLoading(defers);

    if (!defers) {

        m_frame->redirectScheduler()->startTimer();

        startCheckCompleteTimer();

    }

}

Frame* FrameLoader::createWindow(FrameLoader* frameLoaderForFrameLookup, const FrameLoadRequest& request, const WindowFeatures& features, bool& created)

{ 

    ASSERT(!features.dialog || request.frameName().isEmpty());

    if (!request.frameName().isEmpty() && request.frameName() != "_blank") {

        Frame* frame = frameLoaderForFrameLookup->frame()->tree()->find(request.frameName());

        if (frame && shouldAllowNavigation(frame)) {

            if (!request.resourceRequest().url().isEmpty())

                frame->loader()->loadFrameRequest(request, false, false, 0, 0, SendReferrer);

            if (Page* page = frame->page())

                page->chrome()->focus();

            created = false;

            return frame;

        }

    }

    // Sandboxed frames cannot open new auxiliary browsing contexts.

    if (isDocumentSandboxed(m_frame, SandboxNavigation))

        return 0;

    // FIXME: Setting the referrer should be the caller's responsibility.

    FrameLoadRequest requestWithReferrer = request;

    requestWithReferrer.resourceRequest().setHTTPReferrer(m_outgoingReferrer);

    addHTTPOriginIfNeeded(requestWithReferrer.resourceRequest(), outgoingOrigin());

    Page* oldPage = m_frame->page();

    if (!oldPage)

        return 0;

    Page* page = oldPage->chrome()->createWindow(m_frame, requestWithReferrer, features);

    if (!page)

        return 0;

    Frame* frame = page->mainFrame();

    if (request.frameName() != "_blank")

        frame->tree()->setName(request.frameName());

    page->chrome()->setToolbarsVisible(features.toolBarVisible || features.locationBarVisible);

    page->chrome()->setStatusbarVisible(features.statusBarVisible);

    page->chrome()->setScrollbarsVisible(features.scrollbarsVisible);

    page->chrome()->setMenubarVisible(features.menuBarVisible);

    page->chrome()->setResizable(features.resizable);

    // 'x' and 'y' specify the location of the window, while 'width' and 'height' 

    // specify the size of the page. We can only resize the window, so 

    // adjust for the difference between the window size and the page size.

    FloatRect windowRect = page->chrome()->windowRect();

    FloatSize pageSize = page->chrome()->pageRect().size();

    if (features.xSet)

        windowRect.setX(features.x);

    if (features.ySet)

        windowRect.setY(features.y);

    if (features.widthSet)

        windowRect.setWidth(features.width + (windowRect.width() - pageSize.width()));

    if (features.heightSet)

        windowRect.setHeight(features.height + (windowRect.height() - pageSize.height()));

    page->chrome()->setWindowRect(windowRect);

    page->chrome()->show();

    created = true;

    return frame;

}

bool FrameLoader::canHandleRequest(const ResourceRequest& request)

{

    return m_client->canHandleRequest(request);

}

void FrameLoader::changeLocation(const KURL& url, const String& referrer, bool lockHistory, bool lockBackForwardList, bool userGesture, bool refresh)

{

    RefPtr<Frame> protect(m_frame);

    ResourceRequest request(url, referrer, refresh ? ReloadIgnoringCacheData : UseProtocolCachePolicy);

    urlSelected(request, "_self", 0, lockHistory, lockBackForwardList, userGesture, SendReferrer, ReplaceDocumentIfJavaScriptURL);

}

void FrameLoader::urlSelected(const KURL& url, const String& passedTarget, PassRefPtr<Event> triggeringEvent, bool lockHistory, bool lockBackForwardList, bool userGesture, ReferrerPolicy referrerPolicy)

{

    urlSelected(ResourceRequest(url), passedTarget, triggeringEvent, lockHistory, lockBackForwardList, userGesture, referrerPolicy, DoNotReplaceDocumentIfJavaScriptURL);

}

// The shouldReplaceDocumentIfJavaScriptURL parameter will go away when the FIXME to eliminate the

// corresponding parameter from ScriptController::executeIfJavaScriptURL() is addressed.

void FrameLoader::urlSelected(const ResourceRequest& request, const String& passedTarget, PassRefPtr<Event> triggeringEvent, bool lockHistory, bool lockBackForwardList, bool userGesture, ReferrerPolicy referrerPolicy, ShouldReplaceDocumentIfJavaScriptURL shouldReplaceDocumentIfJavaScriptURL)

{

    ASSERT(!m_suppressOpenerInNewFrame);

    if (m_frame->script()->executeIfJavaScriptURL(request.url(), userGesture, shouldReplaceDocumentIfJavaScriptURL))

        return;

    String target = passedTarget;

    if (target.isEmpty())

        target = m_frame->document()->baseTarget();

    FrameLoadRequest frameRequest(request, target);

    if (referrerPolicy == NoReferrer)

        m_suppressOpenerInNewFrame = true;

    else if (frameRequest.resourceRequest().httpReferrer().isEmpty())

        frameRequest.resourceRequest().setHTTPReferrer(m_outgoingReferrer);

    addHTTPOriginIfNeeded(frameRequest.resourceRequest(), outgoingOrigin());

    loadFrameRequest(frameRequest, lockHistory, lockBackForwardList, triggeringEvent, 0, referrerPolicy);

    m_suppressOpenerInNewFrame = false;

}

void FrameLoader::submitForm(PassRefPtr<FormSubmission> submission)

{

    ASSERT(submission->method() == FormSubmission::PostMethod || submission->method() == FormSubmission::GetMethod);

    // FIXME: Find a good spot for these.

    ASSERT(submission->data());

    ASSERT(submission->state());

    ASSERT(submission->state()->sourceFrame() == m_frame);

    if (!m_frame->page())

        return;

    if (submission->action().isEmpty())

        return;

    if (isDocumentSandboxed(m_frame, SandboxForms))

        return;

    if (protocolIsJavaScript(submission->action())) {

        m_isExecutingJavaScriptFormAction = true;

        m_frame->script()->executeIfJavaScriptURL(submission->action(), false, DoNotReplaceDocumentIfJavaScriptURL);

        m_isExecutingJavaScriptFormAction = false;

        return;

    }

    Frame* targetFrame = m_frame->tree()->find(submission->target());

    if (!shouldAllowNavigation(targetFrame))

        return;

    if (!targetFrame) {

        if (!DOMWindow::allowPopUp(m_frame) && !isProcessingUserGesture())

            return;

        targetFrame = m_frame;

    } else

        submission->clearTarget();

    if (!targetFrame->page())

        return;

    // FIXME: We'd like to remove this altogether and fix the multiple form submission issue another way.

    // We do not want to submit more than one form from the same page, nor do we want to submit a single

    // form more than once. This flag prevents these from happening; not sure how other browsers prevent this.

    // The flag is reset in each time we start handle a new mouse or key down event, and

    // also in setView since this part may get reused for a page from the back/forward cache.

    // The form multi-submit logic here is only needed when we are submitting a form that affects this frame.

    // FIXME: Frame targeting is only one of the ways the submission could end up doing something other

    // than replacing this frame's content, so this check is flawed. On the other hand, the check is hardly

    // needed any more now that we reset m_submittedFormURL on each mouse or key down event.

    if (m_frame->tree()->isDescendantOf(targetFrame)) {

        if (m_submittedFormURL == submission->action())

            return;

        m_submittedFormURL = submission->action();

    }

    submission->data()->generateFiles(m_frame->document());

    submission->setReferrer(m_outgoingReferrer);

    submission->setOrigin(outgoingOrigin());

    targetFrame->redirectScheduler()->scheduleFormSubmission(submission);

}

void FrameLoader::stopLoading(UnloadEventPolicy unloadEventPolicy, DatabasePolicy databasePolicy)

{

    if (m_frame->document() && m_frame->document()->parser())

        m_frame->document()->parser()->stopParsing();

    if (unloadEventPolicy != UnloadEventPolicyNone) {

        if (m_frame->document()) {

            if (m_didCallImplicitClose && !m_wasUnloadEventEmitted) {

                Node* currentFocusedNode = m_frame->document()->focusedNode();

                if (currentFocusedNode)

                    currentFocusedNode->aboutToUnload();

                m_pageDismissalEventBeingDispatched = true;

                if (m_frame->domWindow()) {

                    if (unloadEventPolicy == UnloadEventPolicyUnloadAndPageHide)

                        m_frame->domWindow()->dispatchEvent(PageTransitionEvent::create(eventNames().pagehideEvent, m_frame->document()->inPageCache()), m_frame->document());

                    if (!m_frame->document()->inPageCache()) {

                        m_frame->domWindow()->dispatchEvent(Event::create(eventNames().unloadEvent, false, false), m_frame->domWindow()->document());

                        if (m_provisionalDocumentLoader) {

                            DocumentLoadTiming* timing = m_provisionalDocumentLoader->timing();

                            ASSERT(timing->navigationStart);

                            // FIXME: This fails in Safari (https://bugs.webkit.org/show_bug.cgi?id=42772). Understand why.

                            // ASSERT(!timing->unloadEventEnd);

                            timing->unloadEventEnd = currentTime();

                            ASSERT(timing->unloadEventEnd >= timing->navigationStart);

                        }

                    }

                }

                m_pageDismissalEventBeingDispatched = false;

                if (m_frame->document())

                    m_frame->document()->updateStyleIfNeeded();

                m_wasUnloadEventEmitted = true;

            }

        }

        // Dispatching the unload event could have made m_frame->document() null.

        if (m_frame->document() && !m_frame->document()->inPageCache()) {

            // Don't remove event listeners from a transitional empty document (see bug 28716 for more information).

            bool keepEventListeners = m_stateMachine.isDisplayingInitialEmptyDocument() && m_provisionalDocumentLoader

                && m_frame->document()->securityOrigin()->isSecureTransitionTo(m_provisionalDocumentLoader->url());

            if (!keepEventListeners)

                m_frame->document()->removeAllEventListeners();

        }

    }

    m_isComplete = true; // to avoid calling completed() in finishedParsing()

    m_isLoadingMainResource = false;

    m_didCallImplicitClose = true; // don't want that one either

    if (m_frame->document() && m_frame->document()->parsing()) {

        finishedParsing();

        m_frame->document()->setParsing(false);

    }

    m_workingURL = KURL();

    if (Document* doc = m_frame->document()) {

        if (DocLoader* docLoader = doc->docLoader())

            cache()->loader()->cancelRequests(docLoader);

#if ENABLE(DATABASE)

        if (databasePolicy == DatabasePolicyStop)

            doc->stopDatabases(0);

#else

    UNUSED_PARAM(databasePolicy);

#endif

    }

    // FIXME: This will cancel redirection timer, which really needs to be restarted when restoring the frame from b/f cache.

    m_frame->redirectScheduler()->cancel();

}

void FrameLoader::stop()

{

    // http://bugs.webkit.org/show_bug.cgi?id=10854

    // The frame's last ref may be removed and it will be deleted by checkCompleted().

    RefPtr<Frame> protector(m_frame);

    if (m_frame->document()->parser())

        m_frame->document()->parser()->stopParsing();

    m_frame->document()->finishParsing();

    if (m_iconLoader)

        m_iconLoader->stopLoading();

}

bool FrameLoader::closeURL()

{

    history()->saveDocumentState();

    // Should only send the pagehide event here if the current document exists and has not been placed in the page cache.    

    Document* currentDocument = m_frame->document();

    stopLoading(currentDocument && !currentDocument->inPageCache() ? UnloadEventPolicyUnloadAndPageHide : UnloadEventPolicyUnloadOnly);