/*

 * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>

 *                     1999 Lars Knoll <knoll@kde.org>

 *                     1999 Antti Koivisto <koivisto@kde.org>

 *                     2000 Dirk Mueller <mueller@kde.org>

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

 *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)

 *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)

 * Copyright (C) 2009 Google Inc. All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "config.h"

#include "FrameView.h"

#include "AXObjectCache.h"

#include "CSSStyleSelector.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "DocLoader.h"

#include "EventHandler.h"

#include "FloatRect.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameLoaderClient.h"

#include "FrameTree.h"

#include "GraphicsContext.h"

#include "HTMLDocument.h"

#include "HTMLFrameElement.h"

#include "HTMLFrameSetElement.h"

#include "HTMLNames.h"

#include "InspectorTimelineAgent.h"

#include "OverflowEvent.h"

#include "RenderEmbeddedObject.h"

#include "RenderPart.h"

#include "RenderScrollbar.h"

#include "RenderScrollbarPart.h"

#include "RenderTheme.h"

#include "RenderView.h"

#include "Settings.h"

#include "TextResourceDecoder.h"

#include <wtf/CurrentTime.h>

#if USE(ACCELERATED_COMPOSITING)

#include "RenderLayerCompositor.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

#if ENABLE(TILED_BACKING_STORE)

#include "TiledBackingStore.h"

#endif

namespace WebCore {

using namespace HTMLNames;

double FrameView::sCurrentPaintTimeStamp = 0.0;

#if ENABLE(REPAINT_THROTTLING)

// Normal delay

// Negative value would mean that first few repaints happen without a delay

// The delay grows on each repaint to this maximum value

// On each repaint the delay increses by this amount

#else

// FIXME: Repaint throttling could be good to have on all platform.

// The balance between CPU use and repaint frequency will need some tuning for desktop.

// More hooks may be needed to reset the delay on things like GIF and CSS animations.

#endif

// The maximum number of updateWidgets iterations that should be done before returning.

static const unsigned maxUpdateWidgetsIterations = 2;

struct ScheduledEvent : Noncopyable {

    RefPtr<Event> m_event;

    RefPtr<Node> m_eventTarget;

};

FrameView::FrameView(Frame* frame)

    : m_frame(frame)

    , m_canHaveScrollbars(true)

    , m_slowRepaintObjectCount(0)

    , m_fixedObjectCount(0)

    , m_layoutTimer(this, &FrameView::layoutTimerFired)

    , m_layoutRoot(0)

    , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)

    , m_isTransparent(false)

    , m_baseBackgroundColor(Color::white)

    , m_mediaType("screen")

    , m_enqueueEvents(0)

    , m_overflowStatusDirty(true)

    , m_viewportRenderer(0)

    , m_wasScrolledByUser(false)

    , m_inProgrammaticScroll(false)

    , m_deferredRepaintTimer(this, &FrameView::deferredRepaintTimerFired)

    , m_shouldUpdateWhileOffscreen(true)

    , m_deferSetNeedsLayouts(0)

    , m_setNeedsLayoutWasDeferred(false)

    , m_scrollCorner(0)

{

    init();

}

PassRefPtr<FrameView> FrameView::create(Frame* frame)

{

    RefPtr<FrameView> view = adoptRef(new FrameView(frame));

    view->show();

    return view.release();

}

PassRefPtr<FrameView> FrameView::create(Frame* frame, const IntSize& initialSize)

{

    RefPtr<FrameView> view = adoptRef(new FrameView(frame));

    view->Widget::setFrameRect(IntRect(view->pos(), initialSize));

    view->show();

    return view.release();

}

FrameView::~FrameView()

{

    if (m_postLayoutTasksTimer.isActive()) {

        m_postLayoutTasksTimer.stop();

        m_scheduledEvents.clear();

        m_enqueueEvents = 0;

    }

    resetScrollbars();

    // Custom scrollbars should already be destroyed at this point

    ASSERT(!horizontalScrollbar() || !horizontalScrollbar()->isCustomScrollbar());

    ASSERT(!verticalScrollbar() || !verticalScrollbar()->isCustomScrollbar());

    setHasHorizontalScrollbar(false); // Remove native scrollbars now before we lose the connection to the HostWindow.

    setHasVerticalScrollbar(false);

    ASSERT(!m_scrollCorner);

    ASSERT(m_scheduledEvents.isEmpty());

    ASSERT(!m_enqueueEvents);

    if (m_frame) {

        ASSERT(m_frame->view() != this || !m_frame->contentRenderer());

        RenderPart* renderer = m_frame->ownerRenderer();

        if (renderer && renderer->widget() == this)

            renderer->setWidget(0);

    }

}

void FrameView::reset()

{

    m_useSlowRepaints = false;

    m_isOverlapped = false;

    m_contentIsOpaque = false;

    m_borderX = 30;

    m_borderY = 30;

    m_layoutTimer.stop();

    m_layoutRoot = 0;

    m_delayedLayout = false;

    m_doFullRepaint = true;

    m_layoutSchedulingEnabled = true;

    m_midLayout = false;

    m_layoutCount = 0;

    m_nestedLayoutCount = 0;

    m_postLayoutTasksTimer.stop();

    m_firstLayout = true;

    m_firstLayoutCallbackPending = false;

    m_wasScrolledByUser = false;

    m_lastLayoutSize = IntSize();

    m_lastZoomFactor = 1.0f;

    m_deferringRepaints = 0;

    m_repaintCount = 0;

    m_repaintRects.clear();

    m_deferredRepaintTimer.stop();

    m_lastPaintTime = 0;

    m_paintBehavior = PaintBehaviorNormal;

    m_isPainting = false;

    m_isVisuallyNonEmpty = false;

    m_firstVisuallyNonEmptyLayoutCallbackPending = true;

    m_maintainScrollPositionAnchor = 0;

}

bool FrameView::isFrameView() const 

{ 

    return true; 

}

void FrameView::clearFrame()

{

    m_frame = 0;

}

void FrameView::resetScrollbars()

{

    // Reset the document's scrollbars back to our defaults before we yield the floor.

    m_firstLayout = true;

    setScrollbarsSuppressed(true);

    if (m_canHaveScrollbars)

        setScrollbarModes(ScrollbarAuto, ScrollbarAuto);

    else

        setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);

    setScrollbarsSuppressed(false);

}

void FrameView::init()

{

    reset();

    m_margins = IntSize(-1, -1); // undefined

    m_size = IntSize();

    // Propagate the marginwidth/height and scrolling modes to the view.

    Element* ownerElement = m_frame && m_frame->document() ? m_frame->document()->ownerElement() : 0;

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

        HTMLFrameElement* frameElt = static_cast<HTMLFrameElement*>(ownerElement);

        if (frameElt->scrollingMode() == ScrollbarAlwaysOff)

            setCanHaveScrollbars(false);

        int marginWidth = frameElt->getMarginWidth();

        int marginHeight = frameElt->getMarginHeight();

        if (marginWidth != -1)

            setMarginWidth(marginWidth);

        if (marginHeight != -1)

            setMarginHeight(marginHeight);

    }

}

void FrameView::detachCustomScrollbars()

{

    if (!m_frame)

        return;

    Scrollbar* horizontalBar = horizontalScrollbar();

    if (horizontalBar && horizontalBar->isCustomScrollbar() && !toRenderScrollbar(horizontalBar)->owningRenderer()->isRenderPart())

        setHasHorizontalScrollbar(false);

    Scrollbar* verticalBar = verticalScrollbar();

    if (verticalBar && verticalBar->isCustomScrollbar() && !toRenderScrollbar(verticalBar)->owningRenderer()->isRenderPart())

        setHasVerticalScrollbar(false);

    if (m_scrollCorner) {

        m_scrollCorner->destroy();

        m_scrollCorner = 0;

    }

}

void FrameView::clear()

{

    setCanBlitOnScroll(true);

    reset();

    if (m_frame) {

        if (RenderPart* renderer = m_frame->ownerRenderer())

            renderer->viewCleared();

    }

    setScrollbarsSuppressed(true);

}

bool FrameView::didFirstLayout() const

{

    return !m_firstLayout;

}

void FrameView::invalidateRect(const IntRect& rect)

{

    if (!parent()) {

        if (hostWindow())

            hostWindow()->invalidateContentsAndWindow(rect, false /*immediate*/);

        return;

    }

    if (!m_frame)

        return;

    RenderPart* renderer = m_frame->ownerRenderer();

    if (!renderer)

        return;

    IntRect repaintRect = rect;

    repaintRect.move(renderer->borderLeft() + renderer->paddingLeft(),

                     renderer->borderTop() + renderer->paddingTop());

    renderer->repaintRectangle(repaintRect);

}

void FrameView::setMarginWidth(int w)

{

    // make it update the rendering area when set

    m_margins.setWidth(w);

}

void FrameView::setMarginHeight(int h)

{

    // make it update the rendering area when set

    m_margins.setHeight(h);

}

bool FrameView::avoidScrollbarCreation()

{

    ASSERT(m_frame);

    // with frame flattening no subframe can have scrollbars

    // but we also cannot turn scrollbars of as we determine

    // our flattening policy using that.

    if (!m_frame->ownerElement())

        return false;

    if (!m_frame->settings() || m_frame->settings()->frameFlatteningEnabled())

        return true;

    return false;

}

void FrameView::setCanHaveScrollbars(bool canHaveScrollbars)

{

    m_canHaveScrollbars = canHaveScrollbars;

    ScrollView::setCanHaveScrollbars(canHaveScrollbars);

}

void FrameView::updateCanHaveScrollbars()

{

    ScrollbarMode hMode;

    ScrollbarMode vMode;

    scrollbarModes(hMode, vMode);

    if (hMode == ScrollbarAlwaysOff && vMode == ScrollbarAlwaysOff)

        m_canHaveScrollbars = false;

    else

        m_canHaveScrollbars = true;

}

PassRefPtr<Scrollbar> FrameView::createScrollbar(ScrollbarOrientation orientation)

{

    // FIXME: We need to update the scrollbar dynamically as documents change (or as doc elements and bodies get discovered that have custom styles).

    Document* doc = m_frame->document();

    // Try the <body> element first as a scrollbar source.

    Element* body = doc ? doc->body() : 0;

    if (body && body->renderer() && body->renderer()->style()->hasPseudoStyle(SCROLLBAR))

        return RenderScrollbar::createCustomScrollbar(this, orientation, body->renderer()->enclosingBox());

    // If the <body> didn't have a custom style, then the root element might.

    Element* docElement = doc ? doc->documentElement() : 0;

    if (docElement && docElement->renderer() && docElement->renderer()->style()->hasPseudoStyle(SCROLLBAR))

        return RenderScrollbar::createCustomScrollbar(this, orientation, docElement->renderBox());

    // If we have an owning iframe/frame element, then it can set the custom scrollbar also.

    RenderPart* frameRenderer = m_frame->ownerRenderer();

    if (frameRenderer && frameRenderer->style()->hasPseudoStyle(SCROLLBAR))

        return RenderScrollbar::createCustomScrollbar(this, orientation, frameRenderer);

    // Nobody set a custom style, so we just use a native scrollbar.

    return ScrollView::createScrollbar(orientation);

}

void FrameView::setContentsSize(const IntSize& size)

{

    if (size == contentsSize())

        return;

    m_deferSetNeedsLayouts++;

    ScrollView::setContentsSize(size);

    Page* page = frame() ? frame()->page() : 0;

    if (!page)

        return;

    page->chrome()->contentsSizeChanged(frame(), size); //notify only

    m_deferSetNeedsLayouts--;

    if (!m_deferSetNeedsLayouts)

        m_setNeedsLayoutWasDeferred = false; // FIXME: Find a way to make the deferred layout actually happen.

}

void FrameView::adjustViewSize()

{

    ASSERT(m_frame->view() == this);

    RenderView* root = m_frame->contentRenderer();

    if (!root)

        return;

    setContentsSize(IntSize(root->rightLayoutOverflow(), root->bottomLayoutOverflow()));

}

void FrameView::applyOverflowToViewport(RenderObject* o, ScrollbarMode& hMode, ScrollbarMode& vMode)

{

    // Handle the overflow:hidden/scroll case for the body/html elements.  WinIE treats

    // overflow:hidden and overflow:scroll on <body> as applying to the document's

    // scrollbars.  The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should

    // use the root element.

    switch (o->style()->overflowX()) {

        case OHIDDEN:

            hMode = ScrollbarAlwaysOff;

            break;

        case OSCROLL:

            hMode = ScrollbarAlwaysOn;

            break;

        case OAUTO:

            hMode = ScrollbarAuto;

            break;

        default:

            // Don't set it at all.

            ;

    }

     switch (o->style()->overflowY()) {

        case OHIDDEN:

            vMode = ScrollbarAlwaysOff;

            break;

        case OSCROLL:

            vMode = ScrollbarAlwaysOn;

            break;

        case OAUTO:

            vMode = ScrollbarAuto;

            break;

        default:

            // Don't set it at all.

            ;

    }

    m_viewportRenderer = o;

}

#if USE(ACCELERATED_COMPOSITING)

void FrameView::updateCompositingLayers()

{

    RenderView* view = m_frame->contentRenderer();

    if (!view)

        return;

    // This call will make sure the cached hasAcceleratedCompositing is updated from the pref

    view->compositor()->cacheAcceleratedCompositingFlags();

    if (!view->usesCompositing())

        return;

    view->compositor()->updateCompositingLayers(CompositingUpdateAfterLayoutOrStyleChange);

}

void FrameView::setNeedsOneShotDrawingSynchronization()

{

    Page* page = frame() ? frame()->page() : 0;

    if (page)

        page->chrome()->client()->setNeedsOneShotDrawingSynchronization();

}

#endif // USE(ACCELERATED_COMPOSITING)

bool FrameView::syncCompositingStateRecursive()

{

#if USE(ACCELERATED_COMPOSITING)

    ASSERT(m_frame->view() == this);

    RenderView* contentRenderer = m_frame->contentRenderer();

    if (!contentRenderer)

        return true;    // We don't want to keep trying to update layers if we have no renderer.

    if (m_layoutTimer.isActive()) {

        // Don't sync layers if there's a layout pending.

        return false;

    }

    if (GraphicsLayer* rootLayer = contentRenderer->compositor()->rootPlatformLayer())

        rootLayer->syncCompositingState();

    bool allSubframesSynced = true;

    const HashSet<RefPtr<Widget> >* viewChildren = children();

    HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end();

    for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end; ++current) {

        Widget* widget = (*current).get();

        if (widget->isFrameView()) {

            bool synced = static_cast<FrameView*>(widget)->syncCompositingStateRecursive();

            allSubframesSynced &= synced;

        }

    }

    return allSubframesSynced;

#else // USE(ACCELERATED_COMPOSITING)

    return true;

#endif

}

bool FrameView::isSoftwareRenderable() const

{

#if USE(ACCELERATED_COMPOSITING)

    RenderView* view = m_frame->contentRenderer();

    if (!view)

        return true;