/*

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

 */

// How ownership works

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

//

// Big oh represents a refcounted relationship: owner O--- ownee

//

// WebView (for the toplevel frame only)

//    O

//    |

//   Page O------- Frame (m_mainFrame) O-------O FrameView

//                   ||

//                   ||

//               FrameLoader O-------- WebFrame (via FrameLoaderClient)

//

// FrameLoader and Frame are formerly one object that was split apart because

// it got too big. They basically have the same lifetime, hence the double line.

//

// WebFrame is refcounted and has one ref on behalf of the FrameLoader/Frame.

// This is not a normal reference counted pointer because that would require

// changing WebKit code that we don't control. Instead, it is created with this

// ref initially and it is removed when the FrameLoader is getting destroyed.

//

// WebFrames are created in two places, first in WebViewImpl when the root

// frame is created, and second in WebFrame::CreateChildFrame when sub-frames

// are created. WebKit will hook up this object to the FrameLoader/Frame

// and the refcount will be correct.

//

// How frames are destroyed

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

//

// The main frame is never destroyed and is re-used. The FrameLoader is re-used

// and a reference to the main frame is kept by the Page.

//

// When frame content is replaced, all subframes are destroyed. This happens

// in FrameLoader::detachFromParent for each subframe.

//

// Frame going away causes the FrameLoader to get deleted. In FrameLoader's

// destructor, it notifies its client with frameLoaderDestroyed. This calls

// WebFrame::Closing and then derefs the WebFrame and will cause it to be

// deleted (unless an external someone is also holding a reference).

#include "config.h"

#include "WebFrameImpl.h"

#include "Chrome.h"

#include "ChromiumBridge.h"

#include "ClipboardUtilitiesChromium.h"

#include "Console.h"

#include "DOMUtilitiesPrivate.h"

#include "DOMWindow.h"

#include "Document.h"

#include "DocumentFragment.h" // Only needed for ReplaceSelectionCommand.h :(

#include "DocumentLoader.h"

#include "DocumentMarker.h"

#include "Editor.h"

#include "EventHandler.h"

#include "FormState.h"

#include "FrameLoadRequest.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLCollection.h"

#include "HTMLFormElement.h"

#include "HTMLFrameOwnerElement.h"

#include "HTMLHeadElement.h"

#include "HTMLInputElement.h"

#include "HTMLLinkElement.h"

#include "HTMLNames.h"

#include "HistoryItem.h"

#include "InspectorController.h"

#include "Page.h"

#include "PlatformContextSkia.h"

#include "PluginDocument.h"

#include "PrintContext.h"

#include "RenderFrame.h"

#include "RenderTreeAsText.h"

#include "RenderView.h"

#include "RenderWidget.h"

#include "ReplaceSelectionCommand.h"

#include "ResourceHandle.h"

#include "ResourceRequest.h"

#include "ScriptController.h"

#include "ScriptSourceCode.h"

#include "ScriptValue.h"

#include "ScrollTypes.h"

#include "ScrollbarTheme.h"

#include "SelectionController.h"

#include "Settings.h"

#include "SkiaUtils.h"

#include "SubstituteData.h"

#include "TextAffinity.h"

#include "TextIterator.h"

#include "WebAnimationControllerImpl.h"

#include "WebConsoleMessage.h"

#include "WebDataSourceImpl.h"

#include "WebDocument.h"

#include "WebFindOptions.h"

#include "WebFormElement.h"

#include "WebFrameClient.h"

#include "WebHistoryItem.h"

#include "WebInputElement.h"

#include "WebPasswordAutocompleteListener.h"

#include "WebPlugin.h"

#include "WebPluginContainerImpl.h"

#include "WebRange.h"

#include "WebRect.h"

#include "WebScriptSource.h"

#include "WebSecurityOrigin.h"

#include "WebSize.h"

#include "WebURLError.h"

#include "WebVector.h"

#include "WebViewImpl.h"

#include "XPathResult.h"

#include "markup.h"

#include <algorithm>

#include <wtf/CurrentTime.h>

#if OS(DARWIN)

#include "LocalCurrentGraphicsContext.h"

#endif

#if OS(LINUX)

#include <gdk/gdk.h>

#endif

using namespace WebCore;

namespace WebKit {

static int frameCount = 0;

// Key for a StatsCounter tracking how many WebFrames are active.

static const char* const webFrameActiveCount = "WebFrameActiveCount";

static const char* const osdType = "application/opensearchdescription+xml";

static const char* const osdRel = "search";

// Backend for contentAsPlainText, this is a recursive function that gets

// the text for the current frame and all of its subframes. It will append

// the text of each frame in turn to the |output| up to |maxChars| length.

//

// The |frame| must be non-null.

static void frameContentAsPlainText(size_t maxChars, Frame* frame,

                                    Vector<UChar>* output)

{

    Document* doc = frame->document();

    if (!doc)

        return;

    if (!frame->view())

        return;

    // TextIterator iterates over the visual representation of the DOM. As such,

    // it requires you to do a layout before using it (otherwise it'll crash).

    if (frame->view()->needsLayout())

        frame->view()->layout();

    // Select the document body.

    RefPtr<Range> range(doc->createRange());

    ExceptionCode exception = 0;

    range->selectNodeContents(doc->body(), exception);

    if (!exception) {

        // The text iterator will walk nodes giving us text. This is similar to

        // the plainText() function in TextIterator.h, but we implement the maximum

        // size and also copy the results directly into a wstring, avoiding the

        // string conversion.

        for (TextIterator it(range.get()); !it.atEnd(); it.advance()) {

            const UChar* chars = it.characters();

            if (!chars) {

                if (it.length()) {

                    // It appears from crash reports that an iterator can get into a state

                    // where the character count is nonempty but the character pointer is

                    // null. advance()ing it will then just add that many to the null

                    // pointer which won't be caught in a null check but will crash.

                    //

                    // A null pointer and 0 length is common for some nodes.

                    //

                    // IF YOU CATCH THIS IN A DEBUGGER please let brettw know. We don't

                    // currently understand the conditions for this to occur. Ideally, the

                    // iterators would never get into the condition so we should fix them

                    // if we can.

                    ASSERT_NOT_REACHED();

                    break;

                }

                // Just got a null node, we can forge ahead!

                continue;

            }

            size_t toAppend =

                std::min(static_cast<size_t>(it.length()), maxChars - output->size());

            output->append(chars, toAppend);

            if (output->size() >= maxChars)

                return; // Filled up the buffer.

        }

    }

    // The separator between frames when the frames are converted to plain text.

    const UChar frameSeparator[] = { '\n', '\n' };

    const size_t frameSeparatorLen = 2;

    // Recursively walk the children.

    FrameTree* frameTree = frame->tree();

    for (Frame* curChild = frameTree->firstChild(); curChild; curChild = curChild->tree()->nextSibling()) {

        // Make sure the frame separator won't fill up the buffer, and give up if

        // it will. The danger is if the separator will make the buffer longer than

        // maxChars. This will cause the computation above:

        //   maxChars - output->size()

        // to be a negative number which will crash when the subframe is added.

        if (output->size() >= maxChars - frameSeparatorLen)

            return;

        output->append(frameSeparator, frameSeparatorLen);

        frameContentAsPlainText(maxChars, curChild, output);

        if (output->size() >= maxChars)

            return; // Filled up the buffer.

    }

}

WebPluginContainerImpl* WebFrameImpl::pluginContainerFromFrame(Frame* frame)

{

    if (!frame)

        return 0;

    if (!frame->document() || !frame->document()->isPluginDocument())

        return 0;

    PluginDocument* pluginDocument = static_cast<PluginDocument*>(frame->document());

    return static_cast<WebPluginContainerImpl *>(pluginDocument->pluginWidget());

}

// Simple class to override some of PrintContext behavior. Some of the methods

// made virtual so that they can be overriden by ChromePluginPrintContext.

class ChromePrintContext : public PrintContext, public Noncopyable {

public:

    ChromePrintContext(Frame* frame)

        : PrintContext(frame)

        , m_printedPageWidth(0)

    {

    }

    virtual void begin(float width)

    {

        ASSERT(!m_printedPageWidth);

        m_printedPageWidth = width;

        PrintContext::begin(m_printedPageWidth);

    }

    virtual void end()

    {

        PrintContext::end();

    }

    virtual float getPageShrink(int pageNumber) const

    {

        IntRect pageRect = m_pageRects[pageNumber];

        return m_printedPageWidth / pageRect.width();

    }

    // Spools the printed page, a subrect of m_frame. Skip the scale step.

    // NativeTheme doesn't play well with scaling. Scaling is done browser side

    // instead. Returns the scale to be applied.

    // On Linux, we don't have the problem with NativeTheme, hence we let WebKit

    // do the scaling and ignore the return value.

    virtual float spoolPage(GraphicsContext& ctx, int pageNumber)

    {

        IntRect pageRect = m_pageRects[pageNumber];

        float scale = m_printedPageWidth / pageRect.width();

        ctx.save();

#if OS(LINUX)

        ctx.scale(WebCore::FloatSize(scale, scale));

#endif

        ctx.translate(static_cast<float>(-pageRect.x()),

                      static_cast<float>(-pageRect.y()));

        ctx.clip(pageRect);

        m_frame->view()->paintContents(&ctx, pageRect);

        ctx.restore();

        return scale;

    }

    virtual void computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)

    {

        return PrintContext::computePageRects(printRect, headerHeight, footerHeight, userScaleFactor, outPageHeight);

    }

    virtual int pageCount() const

    {

        return PrintContext::pageCount();

    }

    virtual bool shouldUseBrowserOverlays() const

    {

        return true;

    }

private:

    // Set when printing.

    float m_printedPageWidth;

};

// Simple class to override some of PrintContext behavior. This is used when

// the frame hosts a plugin that supports custom printing. In this case, we

// want to delegate all printing related calls to the plugin.

class ChromePluginPrintContext : public ChromePrintContext {

public:

    ChromePluginPrintContext(Frame* frame, int printerDPI)

        : ChromePrintContext(frame), m_pageCount(0), m_printerDPI(printerDPI)

    {

        // This HAS to be a frame hosting a full-mode plugin

        ASSERT(frame->document()->isPluginDocument());

    }

    virtual void begin(float width)

    {

    }

    virtual void end()

    {

        WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(m_frame);

        if (pluginContainer && pluginContainer->supportsPaginatedPrint())

            pluginContainer->printEnd();

        else

            ASSERT_NOT_REACHED();

    }

    virtual float getPageShrink(int pageNumber) const

    {

        // We don't shrink the page (maybe we should ask the widget ??)

        return 1.0;

    }

    virtual void computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)

    {

        WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(m_frame);

        if (pluginContainer && pluginContainer->supportsPaginatedPrint())

            m_pageCount = pluginContainer->printBegin(IntRect(printRect), m_printerDPI);

        else

            ASSERT_NOT_REACHED();

    }

    virtual int pageCount() const

    {

        return m_pageCount;

    }

    // Spools the printed page, a subrect of m_frame.  Skip the scale step.

    // NativeTheme doesn't play well with scaling. Scaling is done browser side

    // instead.  Returns the scale to be applied.

    virtual float spoolPage(GraphicsContext& ctx, int pageNumber)

    {

        WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(m_frame);

        if (pluginContainer && pluginContainer->supportsPaginatedPrint())

            pluginContainer->printPage(pageNumber, &ctx);

        else

            ASSERT_NOT_REACHED();

        return 1.0;

    }

    virtual bool shouldUseBrowserOverlays() const

    {

        return false;

    }

private:

    // Set when printing.

    int m_pageCount;

    int m_printerDPI;

};

static WebDataSource* DataSourceForDocLoader(DocumentLoader* loader)

{

    return loader ? WebDataSourceImpl::fromDocumentLoader(loader) : 0;

}

// WebFrame -------------------------------------------------------------------

class WebFrameImpl::DeferredScopeStringMatches {

public:

    DeferredScopeStringMatches(WebFrameImpl* webFrame,

                               int identifier,

                               const WebString& searchText,

                               const WebFindOptions& options,

                               bool reset)

        : m_timer(this, &DeferredScopeStringMatches::doTimeout)

        , m_webFrame(webFrame)

        , m_identifier(identifier)

        , m_searchText(searchText)

        , m_options(options)

        , m_reset(reset)

    {

        m_timer.startOneShot(0.0);

    }

private:

    void doTimeout(Timer<DeferredScopeStringMatches>*)

    {

        m_webFrame->callScopeStringMatches(

            this, m_identifier, m_searchText, m_options, m_reset);

    }

    Timer<DeferredScopeStringMatches> m_timer;

    RefPtr<WebFrameImpl> m_webFrame;

    int m_identifier;

    WebString m_searchText;

    WebFindOptions m_options;

    bool m_reset;

};

// WebFrame -------------------------------------------------------------------

int WebFrame::instanceCount()

{

    return frameCount;

}

WebFrame* WebFrame::frameForEnteredContext()

{

    Frame* frame =

        ScriptController::retrieveFrameForEnteredContext();

    return WebFrameImpl::fromFrame(frame);

}

WebFrame* WebFrame::frameForCurrentContext()

{

    Frame* frame =

        ScriptController::retrieveFrameForCurrentContext();

    return WebFrameImpl::fromFrame(frame);

}

WebFrame* WebFrame::fromFrameOwnerElement(const WebElement& element)

{

    return WebFrameImpl::fromFrameOwnerElement(

        PassRefPtr<Element>(element).get());

}

WebString WebFrameImpl::name() const

{

    return m_frame->tree()->name();

}

void WebFrameImpl::setName(const WebString& name)

{

    m_frame->tree()->setName(name);

}

WebURL WebFrameImpl::url() const

{

    const WebDataSource* ds = dataSource();

    if (!ds)

        return WebURL();

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

}

WebURL WebFrameImpl::favIconURL() const

{

    FrameLoader* frameLoader = m_frame->loader();

    // The URL to the favicon may be in the header. As such, only

    // ask the loader for the favicon if it's finished loading.

    if (frameLoader->state() == FrameStateComplete) {

        const KURL& url = frameLoader->iconURL();

        if (!url.isEmpty())

            return url;

    }

    return WebURL();

}

WebURL WebFrameImpl::openSearchDescriptionURL() const

{

    FrameLoader* frameLoader = m_frame->loader();

    if (frameLoader->state() == FrameStateComplete

        && m_frame->document() && m_frame->document()->head()

        && !m_frame->tree()->parent()) {

        HTMLHeadElement* head = m_frame->document()->head();

        if (head) {

            RefPtr<HTMLCollection> children = head->children();

            for (Node* child = children->firstItem(); child; child = children->nextItem()) {

                HTMLLinkElement* linkElement = toHTMLLinkElement(child);

                if (linkElement

                    && linkElement->type() == osdType

                    && linkElement->rel() == osdRel

                    && !linkElement->href().isEmpty())

                    return linkElement->href();

            }

        }

    }

    return WebURL();

}

WebString WebFrameImpl::encoding() const

{

    return frame()->loader()->writer()->encoding();

}

WebSize WebFrameImpl::scrollOffset() const

{