/*

 * Copyright (C) 2006, 2007, 2008, 2009 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 "CString.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 "Frame.h"

#include "FrameLoadRequest.h"

#include "FrameLoaderClient.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "HTMLAnchorElement.h"

#include "HTMLAppletElement.h"

#include "HTMLFormElement.h"

#include "HTMLFrameElement.h"

#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 "RenderPart.h"

#include "RenderView.h"

#include "RenderWidget.h"

#include "ResourceHandle.h"

#include "ResourceRequest.h"

#include "ScriptController.h"

#include "ScriptSourceCode.h"

#include "ScriptString.h"

#include "ScriptValue.h"

#include "SecurityOrigin.h"

#include "SegmentedString.h"

#include "Settings.h"

#if ENABLE(SHARED_WORKERS)

#include "SharedWorkerRepository.h"

#endif

#include "TextResourceDecoder.h"

#include "WindowFeatures.h"

#include "XMLHttpRequest.h"

#include "XMLTokenizer.h"

#include "XSSAuditor.h"

#include <wtf/CurrentTime.h>

#include <wtf/StdLibExtras.h>

#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 {

#if ENABLE(SVG)

using namespace SVGNames;

#endif

using namespace HTMLNames;

#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());

}

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

    : m_frame(frame)

    , m_client(client)

    , m_policyChecker(frame)

    , m_history(frame)

    , m_notifer(frame)

    , m_state(FrameStateCommittedPage)

    , m_loadType(FrameLoadTypeStandard)

    , m_delegateIsHandlingProvisionalLoadError(false)

    , m_firstLayoutDone(false)

    , m_quickRedirectComing(false)

    , m_sentRedirectNotification(false)

    , m_inStopAllLoaders(false)

    , m_isExecutingJavaScriptFormAction(false)

    , m_didCallImplicitClose(false)

    , m_wasUnloadEventEmitted(false)

    , m_unloadEventBeingDispatched(false)

    , m_isComplete(false)

    , m_isLoadingMainResource(false)

    , m_needsClear(false)

    , m_receivedData(false)

    , m_encodingWasChosenByUser(false)

    , m_containsPlugIns(false)

    , m_checkTimer(this, &FrameLoader::checkTimerFired)

    , m_shouldCallCheckCompleted(false)

    , m_shouldCallCheckLoadComplete(false)

    , m_opener(0)

    , m_creatingInitialEmptyDocument(false)

    , m_isDisplayingInitialEmptyDocument(false)

    , m_committedFirstRealDocumentLoad(false)

    , m_didPerformFirstNavigation(false)

    , m_loadingFromCachedPage(false)

    , m_suppressOpenerInNewFrame(false)

#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()

{

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

    m_isDisplayingInitialEmptyDocument = false;

    m_creatingInitialEmptyDocument = true;

    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();

    begin(KURL(), false);

    end();

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

    m_creatingInitialEmptyDocument = false;

    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;

        }

    }

    // 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);

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

        return;

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

}

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

{

    ASSERT(!m_suppressOpenerInNewFrame);

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

        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;

}

bool FrameLoader::requestFrame(HTMLFrameOwnerElement* ownerElement, const String& urlString, const AtomicString& frameName)

{

    // Support for <frame src="javascript:string">

    KURL scriptURL;

    KURL url;

    if (protocolIsJavaScript(urlString)) {

        scriptURL = completeURL(urlString); // completeURL() encodes the URL.

        url = blankURL();

    } else

        url = completeURL(urlString);

    Frame* frame = ownerElement->contentFrame();

    if (frame)

        frame->redirectScheduler()->scheduleLocationChange(url.string(), m_outgoingReferrer, true, true, isProcessingUserGesture());

    else

        frame = loadSubframe(ownerElement, url, frameName, m_outgoingReferrer);

    if (!frame)

        return false;

    if (!scriptURL.isEmpty())

        frame->script()->executeIfJavaScriptURL(scriptURL);

    return true;

}

Frame* FrameLoader::loadSubframe(HTMLFrameOwnerElement* ownerElement, const KURL& url, const String& name, const String& referrer)

{

    bool allowsScrolling = true;

    int marginWidth = -1;

    int marginHeight = -1;

    if (ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(iframeTag)) {

        HTMLFrameElementBase* o = static_cast<HTMLFrameElementBase*>(ownerElement);

        allowsScrolling = o->scrollingMode() != ScrollbarAlwaysOff;

        marginWidth = o->getMarginWidth();

        marginHeight = o->getMarginHeight();

    }

    if (!SecurityOrigin::canLoad(url, referrer, 0)) {

        FrameLoader::reportLocalLoadFailed(m_frame, url.string());

        return 0;

    }

    bool hideReferrer = SecurityOrigin::shouldHideReferrer(url, referrer);

    RefPtr<Frame> frame = m_client->createFrame(url, name, ownerElement, hideReferrer ? String() : referrer, allowsScrolling, marginWidth, marginHeight);

    if (!frame)  {

        checkCallImplicitClose();

        return 0;

    }

    frame->loader()->m_isComplete = false;

    RenderObject* renderer = ownerElement->renderer();

    FrameView* view = frame->view();

    if (renderer && renderer->isWidget() && view)

        toRenderWidget(renderer)->setWidget(view);

    checkCallImplicitClose();

    // In these cases, the synchronous load would have finished

    // before we could connect the signals, so make sure to send the 

    // completed() signal for the child by hand

    // FIXME: In this case the Frame will have finished loading before 

    // it's being added to the child list. It would be a good idea to

    // create the child first, then invoke the loader separately.

    if (url.isEmpty() || url == blankURL()) {

        frame->loader()->completed();

        frame->loader()->checkCompleted();

    }

    return frame.get();

}

void FrameLoader::submitForm(const char* action, const String& url, PassRefPtr<FormData> formData,

    const String& target, const String& contentType, const String& boundary,

    bool lockHistory, PassRefPtr<Event> event, PassRefPtr<FormState> formState)

{

    ASSERT(action);

    ASSERT(strcmp(action, "GET") == 0 || strcmp(action, "POST") == 0);

    ASSERT(formData);

    ASSERT(formState);

    ASSERT(formState->sourceFrame() == m_frame);

    if (!m_frame->page())

        return;

    KURL u = completeURL(url.isNull() ? "" : url);

    if (u.isEmpty())

        return;

    if (protocolIsJavaScript(u)) {

        m_isExecutingJavaScriptFormAction = true;

        m_frame->script()->executeIfJavaScriptURL(u, false, false);

        m_isExecutingJavaScriptFormAction = false;

        return;

    }

    FrameLoadRequest frameRequest;

    String targetOrBaseTarget = target.isEmpty() ? m_frame->document()->baseTarget() : target;

    Frame* targetFrame = findFrameForNavigation(targetOrBaseTarget);

    if (!targetFrame) {

        targetFrame = m_frame;

        frameRequest.setFrameName(targetOrBaseTarget);

    }

    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 == u)

            return;

        m_submittedFormURL = u;

    }

    formData->generateFiles(m_frame->page()->chrome()->client());

    if (!m_outgoingReferrer.isEmpty())

        frameRequest.resourceRequest().setHTTPReferrer(m_outgoingReferrer);

    if (strcmp(action, "GET") == 0)

        u.setQuery(formData->flattenToString());

    else {

        frameRequest.resourceRequest().setHTTPMethod("POST");

        frameRequest.resourceRequest().setHTTPBody(formData);

        // construct some user headers if necessary

        if (contentType.isNull() || contentType == "application/x-www-form-urlencoded")

            frameRequest.resourceRequest().setHTTPContentType(contentType);

        else // contentType must be "multipart/form-data"

            frameRequest.resourceRequest().setHTTPContentType(contentType + "; boundary=" + boundary);

    }

    frameRequest.resourceRequest().setURL(u);

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

    targetFrame->redirectScheduler()->scheduleFormSubmission(frameRequest, lockHistory, event, formState);

}

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

{

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

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

    if (unloadEventPolicy != UnloadEventPolicyNone) {

        if (m_frame->document()) {

            if (m_didCallImplicitClose && !m_wasUnloadEventEmitted) {

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

                if (currentFocusedNode)

                    currentFocusedNode->aboutToUnload();

                m_unloadEventBeingDispatched = 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());

                }

                m_unloadEventBeingDispatched = 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()) {