/*

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

 * Copyright (C) 2007 Trolltech ASA

 *

 * 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 "CString.h"

#include "Cache.h"

#include "CachedPage.h"

#include "Chrome.h"

#include "DOMImplementation.h"

#include "DocLoader.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "EditCommand.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 "FramePrivate.h"

#include "FrameTree.h"

#include "FrameView.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 "ProgressTracker.h"

#include "RenderPart.h"

#include "RenderWidget.h"

#include "ResourceHandle.h"

#include "ResourceRequest.h"

#include "SecurityOrigin.h"

#include "SegmentedString.h"

#include "Settings.h"

#include "SystemTime.h"

#include "TextResourceDecoder.h"

#include "WindowFeatures.h"

#include "XMLHttpRequest.h"

#include "XMLTokenizer.h"

#include "kjs_binding.h"

#include "kjs_proxy.h"

#include "kjs_window.h"

#include <kjs/JSLock.h>

#include <kjs/object.h>

using KJS::UString;

using KJS::JSLock;

using KJS::JSValue;

namespace WebCore {

using namespace HTMLNames;

using namespace EventNames;

#if USE(LOW_BANDWIDTH_DISPLAY)

const unsigned int cMaxPendingSourceLengthInLowBandwidthDisplay = 128 * 1024;

#endif

struct FormSubmission {

    const char* action;

    String URL;

    RefPtr<FormData> data;

    String target;

    String contentType;

    String boundary;

    RefPtr<Event> event;

    FormSubmission(const char* a, const String& u, PassRefPtr<FormData> d, const String& t,

            const String& ct, const String& b, PassRefPtr<Event> e)

        : action(a)

        , URL(u)

        , data(d)

        , target(t)

        , contentType(ct)

        , boundary(b)

        , event(e)

    {

    }

};

struct ScheduledRedirection {

    enum Type { redirection, locationChange, historyNavigation, locationChangeDuringLoad };

    Type type;

    double delay;

    String URL;

    String referrer;

    int historySteps;

    bool lockHistory;

    bool wasUserGesture;

    ScheduledRedirection(double redirectDelay, const String& redirectURL, bool redirectLockHistory, bool userGesture)

        : type(redirection)

        , delay(redirectDelay)

        , URL(redirectURL)

        , historySteps(0)

        , lockHistory(redirectLockHistory)

        , wasUserGesture(userGesture)

    {

    }

    ScheduledRedirection(Type locationChangeType,

            const String& locationChangeURL, const String& locationChangeReferrer,

            bool locationChangeLockHistory, bool locationChangeWasUserGesture)

        : type(locationChangeType)

        , delay(0)

        , URL(locationChangeURL)

        , referrer(locationChangeReferrer)

        , historySteps(0)

        , lockHistory(locationChangeLockHistory)

        , wasUserGesture(locationChangeWasUserGesture)

    {

    }

    explicit ScheduledRedirection(int historyNavigationSteps)

        : type(historyNavigation)

        , delay(0)

        , historySteps(historyNavigationSteps)

        , lockHistory(false)

        , wasUserGesture(false)

    {

    }

};

static double storedTimeOfLastCompletedLoad;

static bool m_restrictAccessToLocal = false;

static bool getString(JSValue* result, String& string)

{

    if (!result)

        return false;

    JSLock lock;

    UString ustring;

    if (!result->getString(ustring))

        return false;

    string = ustring;

    return true;

}

bool isBackForwardLoadType(FrameLoadType type)

{

    switch (type) {

        case FrameLoadTypeStandard:

        case FrameLoadTypeReload:

        case FrameLoadTypeReloadAllowingStaleData:

        case FrameLoadTypeSame:

        case FrameLoadTypeRedirectWithLockedHistory:

        case FrameLoadTypeReplace:

            return false;

        case FrameLoadTypeBack:

        case FrameLoadTypeForward:

        case FrameLoadTypeIndexedBackForward:

            return true;

    }

    ASSERT_NOT_REACHED();

    return false;

}

static int numRequests(Document* document)

{

    if (!document)

        return 0;

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

}

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

    : m_frame(frame)

    , m_client(client)

    , m_state(FrameStateCommittedPage)

    , m_loadType(FrameLoadTypeStandard)

    , m_policyLoadType(FrameLoadTypeStandard)

    , m_delegateIsHandlingProvisionalLoadError(false)

    , m_delegateIsDecidingNavigationPolicy(false)

    , m_delegateIsHandlingUnimplementablePolicy(false)

    , m_firstLayoutDone(false)

    , m_quickRedirectComing(false)

    , m_sentRedirectNotification(false)

    , m_inStopAllLoaders(false)

    , m_navigationDuringLoad(false)

    , m_cachePolicy(CachePolicyVerify)

    , m_isExecutingJavaScriptFormAction(false)

    , m_isRunningScript(false)

    , m_didCallImplicitClose(false)

    , m_wasUnloadEventEmitted(false)

    , m_isComplete(false)

    , m_isLoadingMainResource(false)

    , m_cancellingWithLoadInProgress(false)

    , m_needsClear(false)

    , m_receivedData(false)

    , m_encodingWasChosenByUser(false)

    , m_containsPlugIns(false)

    , m_redirectionTimer(this, &FrameLoader::redirectionTimerFired)

    , m_checkCompletedTimer(this, &FrameLoader::checkCompletedTimerFired)

    , m_checkLoadCompleteTimer(this, &FrameLoader::checkLoadCompleteTimerFired)

    , m_opener(0)

    , m_openedByDOM(false)

    , m_creatingInitialEmptyDocument(false)

    , m_isDisplayingInitialEmptyDocument(false)

    , m_committedFirstRealDocumentLoad(false)

    , m_didPerformFirstNavigation(false)

#if USE(LOW_BANDWIDTH_DISPLAY)

    , m_useLowBandwidthDisplay(true)

    , m_finishedParsingDuringLowBandwidthDisplay(false)

    , m_needToSwitchOutLowBandwidthDisplay(false)

    , m_numOutstandingExternalRequests(0)

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

    m_client->setDefersLoading(defers);

}

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

{ 

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

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

        if (Frame* frame = m_frame->tree()->find(request.frameName())) {

            if (!shouldAllowNavigation(frame))

                return 0;

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

                frame->loader()->load(request, false, true, 0, 0, HashMap<String, String>());

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

    Page* page = m_frame->page();

    if (page) {

        if (features.dialog)

            page = page->chrome()->createModalDialog(m_frame, requestWithReferrer);

        else

            page = page->chrome()->createWindow(m_frame, requestWithReferrer);

    }

    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 String& URL, const String& referrer, bool lockHistory, bool userGesture)

{

    changeLocation(completeURL(URL), referrer, lockHistory, userGesture);

}

void FrameLoader::changeLocation(const KURL& URL, const String& referrer, bool lockHistory, bool userGesture)

{

    if (URL.url().find("javascript:", 0, false) == 0) {

        String script = KURL::decode_string(URL.url().mid(strlen("javascript:")));

        JSValue* result = executeScript(script, userGesture);

        String scriptResult;

        if (getString(result, scriptResult)) {

            begin(m_URL);

            write(scriptResult);

            end();

        }

        return;

    }

    ResourceRequestCachePolicy policy = (m_cachePolicy == CachePolicyReload) || (m_cachePolicy == CachePolicyRefresh)

        ? ReloadIgnoringCacheData : UseProtocolCachePolicy;

    ResourceRequest request(URL, referrer, policy);

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

}

void FrameLoader::urlSelected(const ResourceRequest& request, const String& _target, Event* triggeringEvent, bool lockHistory, bool userGesture)

{

    String target = _target;

    if (target.isEmpty() && m_frame->document())

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

    const KURL& url = request.url();

    if (url.url().startsWith("javascript:", false)) {

        executeScript(KURL::decode_string(url.url().mid(strlen("javascript:"))), true);

        return;

    }

    FrameLoadRequest frameRequest(request, target);

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

        frameRequest.resourceRequest().setHTTPReferrer(m_outgoingReferrer);

    urlSelected(frameRequest, triggeringEvent, lockHistory, userGesture);

}

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

{

#if USE(LOW_BANDWIDTH_DISPLAY)

    // don't create sub-frame during low bandwidth display

    if (frame()->document()->inLowBandwidthDisplay()) {

        m_needToSwitchOutLowBandwidthDisplay = true;

        return false;

    }

#endif

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

    KURL scriptURL;

    KURL url;

    if (urlString.startsWith("javascript:", false)) {

        scriptURL = urlString.deprecatedString();

        url = "about:blank";

    } else

        url = completeURL(urlString);

    Frame* frame = ownerElement->contentFrame();

    if (frame)

        frame->loader()->scheduleLocationChange(url.url(), m_outgoingReferrer, true, userGestureHint());

    else

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

    if (!frame)

        return false;

    if (!scriptURL.isEmpty())

        frame->loader()->replaceContentsWithScriptResult(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 (!canLoad(url, referrer)) {

        FrameLoader::reportLocalLoadFailed(m_frame->page(), url.url());

        return 0;

    }

    bool hideReferrer = 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;

    if (ownerElement->renderer() && frame->view())

        static_cast<RenderWidget*>(ownerElement->renderer())->setWidget(frame->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 == "about:blank") {

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

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

    }

    return frame.get();

}

void FrameLoader::submitFormAgain()

{

    if (m_isRunningScript)

        return;

    OwnPtr<FormSubmission> form(m_deferredFormSubmission.release());

    if (form)

        submitForm(form->action, form->URL, form->data, form->target,

            form->contentType, form->boundary, form->event.get());

}

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

    const String& target, const String& contentType, const String& boundary, Event* event)

{

    ASSERT(formData.get());

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

    // FIXME: Do we really need to special-case an empty URL?

    // Would it be better to just go on with the form submisson and let the I/O fail?

    if (u.isEmpty())

        return;

    DeprecatedString urlString = u.url();

    if (urlString.startsWith("javascript:", false)) {

        m_isExecutingJavaScriptFormAction = true;

        executeScript(KURL::decode_string(urlString.mid(strlen("javascript:"))));

        m_isExecutingJavaScriptFormAction = false;

        return;

    }

    if (m_isRunningScript) {

        if (m_deferredFormSubmission)

            return;

        m_deferredFormSubmission.set(new FormSubmission(action, url, formData, target,

            contentType, boundary, event));

        return;

    }

    FrameLoadRequest frameRequest;

    if (!m_outgoingReferrer.isEmpty())

        frameRequest.resourceRequest().setHTTPReferrer(m_outgoingReferrer);

    frameRequest.setFrameName(target.isEmpty() ? m_frame->document()->baseTarget() : target);