1 /*

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

     3  *                     1999 Lars Knoll <knoll@kde.org>

     4  *                     1999 Antti Koivisto <koivisto@kde.org>

     5  *                     2000 Dirk Mueller <mueller@kde.org>

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

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

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

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

    10  *

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

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

    13  * License as published by the Free Software Foundation; either

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

    15  *

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

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

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

    19  * Library General Public License for more details.

    20  *

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

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

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

    24  * Boston, MA 02110-1301, USA.

    25  */

    26 

    27 #include "config.h"

    28 #include "FrameView.h"

    29 

    30 #include "AXObjectCache.h"

    31 #include "CSSStyleSelector.h"

    32 #include "ChromeClient.h"

    33 #include "DocLoader.h"

    34 #include "EventHandler.h"

    35 #include "FloatRect.h"

    36 #include "FocusController.h"

    37 #include "Frame.h"

    38 #include "FrameLoader.h"

    39 #include "FrameLoaderClient.h"

    40 #include "FrameTree.h"

    41 #include "GraphicsContext.h"

    42 #include "HTMLDocument.h"

    43 #include "HTMLFrameElement.h"

    44 #include "HTMLFrameSetElement.h"

    45 #include "HTMLNames.h"

    46 #include "InspectorTimelineAgent.h"

    47 #include "OverflowEvent.h"

    48 #include "RenderPart.h"

    49 #include "RenderPartObject.h"

    50 #include "RenderScrollbar.h"

    51 #include "RenderScrollbarPart.h"

    52 #include "RenderTheme.h"

    53 #include "RenderView.h"

    54 #include "Settings.h"

    55 #include "TextResourceDecoder.h"

    56 #include <wtf/CurrentTime.h>

    57 

    58 #if USE(ACCELERATED_COMPOSITING)

    59 #include "RenderLayerCompositor.h"

    60 #endif

    61 

    62 #if ENABLE(SVG)

    63 #include "SVGDocument.h"

    64 #include "SVGLocatable.h"

    65 #include "SVGNames.h"

    66 #include "SVGPreserveAspectRatio.h"

    67 #include "SVGSVGElement.h"

    68 #include "SVGViewElement.h"

    69 #include "SVGViewSpec.h"

    70 #endif

    71 

    72 

    73 namespace WebCore {

    74 

    75 using namespace HTMLNames;

    76 

    77 double FrameView::sCurrentPaintTimeStamp = 0.0;

    78 

    79 #if ENABLE(REPAINT_THROTTLING)

    80 // Normal delay

    81 static const double deferredRepaintDelay = 0.025;

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

    83 static const double initialDeferredRepaintDelayDuringLoading = 0;

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

    85 static const double maxDeferredRepaintDelayDuringLoading = 2.5;

    86 // On each repaint the delay increses by this amount

    87 static const double deferredRepaintDelayIncrementDuringLoading = 0.5;

    88 #else

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

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

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

    92 static const double deferredRepaintDelay = 0;

    93 static const double initialDeferredRepaintDelayDuringLoading = 0;

    94 static const double maxDeferredRepaintDelayDuringLoading = 0;

    95 static const double deferredRepaintDelayIncrementDuringLoading = 0;

    96 #endif

    97 

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

    99 static const unsigned maxUpdateWidgetsIterations = 2;

   100 

   101 struct ScheduledEvent {

   102     RefPtr<Event> m_event;

   103     RefPtr<Node> m_eventTarget;

   104 };

   105 

   106 FrameView::FrameView(Frame* frame)

   107     : m_frame(frame)

   108     , m_slowRepaintObjectCount(0)

   109     , m_layoutTimer(this, &FrameView::layoutTimerFired)

   110     , m_layoutRoot(0)

   111     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)

   112     , m_isTransparent(false)

   113     , m_baseBackgroundColor(Color::white)

   114     , m_mediaType("screen")

   115     , m_enqueueEvents(0)

   116     , m_overflowStatusDirty(true)

   117     , m_viewportRenderer(0)

   118     , m_wasScrolledByUser(false)

   119     , m_inProgrammaticScroll(false)

   120     , m_deferredRepaintTimer(this, &FrameView::deferredRepaintTimerFired)

   121     , m_shouldUpdateWhileOffscreen(true)

   122     , m_deferSetNeedsLayouts(0)

   123     , m_setNeedsLayoutWasDeferred(false)

   124     , m_scrollCorner(0)

   125 {

   126     init();

   127 }

   128 

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

   130 {

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

   132     view->show();

   133     return view.release();

   134 }

   135 

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

   137 {

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

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

   140     view->show();

   141     return view.release();

   142 }

   143 

   144 FrameView::~FrameView()

   145 {

   146     if (m_postLayoutTasksTimer.isActive()) {

   147         m_postLayoutTasksTimer.stop();

   148         m_scheduledEvents.clear();

   149         m_enqueueEvents = 0;

   150     }

   151 

   152     resetScrollbars();

   153 

   154     // Custom scrollbars should already be destroyed at this point

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

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

   157 

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

   159     setHasVerticalScrollbar(false);

   160     

   161     ASSERT(!m_scrollCorner);

   162     ASSERT(m_scheduledEvents.isEmpty());

   163     ASSERT(!m_enqueueEvents);

   164 

   165     if (m_frame) {

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

   167         RenderPart* renderer = m_frame->ownerRenderer();

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

   169             renderer->setWidget(0);

   170     }

   171 }

   172 

   173 void FrameView::reset()

   174 {

   175     m_useSlowRepaints = false;

   176     m_isOverlapped = false;

   177     m_contentIsOpaque = false;

   178     m_borderX = 30;

   179     m_borderY = 30;

   180     m_layoutTimer.stop();

   181     m_layoutRoot = 0;

   182     m_delayedLayout = false;

   183     m_doFullRepaint = true;

   184     m_layoutSchedulingEnabled = true;

   185     m_midLayout = false;

   186     m_layoutCount = 0;

   187     m_nestedLayoutCount = 0;

   188     m_postLayoutTasksTimer.stop();

   189     m_firstLayout = true;

   190     m_firstLayoutCallbackPending = false;

   191     m_wasScrolledByUser = false;

   192     m_lastLayoutSize = IntSize();

   193     m_lastZoomFactor = 1.0f;

   194     m_deferringRepaints = 0;

   195     m_repaintCount = 0;

   196     m_repaintRects.clear();

   197     m_deferredRepaintDelay = initialDeferredRepaintDelayDuringLoading;

   198     m_deferredRepaintTimer.stop();

   199     m_lastPaintTime = 0;

   200     m_paintRestriction = PaintRestrictionNone;

   201     m_isPainting = false;

   202     m_isVisuallyNonEmpty = false;

   203     m_firstVisuallyNonEmptyLayoutCallbackPending = true;

   204     m_maintainScrollPositionAnchor = 0;

   205 }

   206 

   207 bool FrameView::isFrameView() const 

   208 { 

   209     return true; 

   210 }

   211 

   212 void FrameView::clearFrame()

   213 {

   214     m_frame = 0;

   215 }

   216 

   217 void FrameView::resetScrollbars()

   218 {

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

   220     m_firstLayout = true;

   221     setScrollbarsSuppressed(true);

   222     setScrollbarModes(ScrollbarAuto, ScrollbarAuto);

   223     setScrollbarsSuppressed(false);

   224 }

   225 

   226 void FrameView::init()

   227 {

   228     reset();

   229 

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

   231     m_size = IntSize();

   232 

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

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

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

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

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

   238             setCanHaveScrollbars(false);

   239         int marginWidth = frameElt->getMarginWidth();

   240         int marginHeight = frameElt->getMarginHeight();

   241         if (marginWidth != -1)

   242             setMarginWidth(marginWidth);

   243         if (marginHeight != -1)

   244             setMarginHeight(marginHeight);

   245     }

   246 }

   247 

   248 void FrameView::detachCustomScrollbars()

   249 {

   250     if (!m_frame)

   251         return;

   252 

   253     Scrollbar* horizontalBar = horizontalScrollbar();

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

   255         setHasHorizontalScrollbar(false);

   256 

   257     Scrollbar* verticalBar = verticalScrollbar();

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

   259         setHasVerticalScrollbar(false);

   260 

   261     if (m_scrollCorner) {

   262         m_scrollCorner->destroy();

   263         m_scrollCorner = 0;

   264     }

   265 }

   266 

   267 void FrameView::clear()

   268 {

   269     setCanBlitOnScroll(true);

   270     

   271     reset();

   272 

   273     if (m_frame) {

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

   275             renderer->viewCleared();

   276     }

   277 

   278     setScrollbarsSuppressed(true);

   279 }

   280 

   281 bool FrameView::didFirstLayout() const

   282 {

   283     return !m_firstLayout;

   284 }

   285 

   286 void FrameView::invalidateRect(const IntRect& rect)

   287 {

   288     if (!parent()) {

   289         if (hostWindow())

   290             hostWindow()->repaint(rect, true);

   291         return;

   292     }

   293 

   294     if (!m_frame)

   295         return;

   296 

   297     RenderPart* renderer = m_frame->ownerRenderer();

   298     if (!renderer)

   299         return;

   300 

   301     IntRect repaintRect = rect;

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

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

   304     renderer->repaintRectangle(repaintRect);

   305 }

   306 

   307 void FrameView::setMarginWidth(int w)

   308 {

   309     // make it update the rendering area when set

   310     m_margins.setWidth(w);

   311 }

   312 

   313 void FrameView::setMarginHeight(int h)

   314 {

   315     // make it update the rendering area when set

   316     m_margins.setHeight(h);

   317 }

   318 

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

   320 {

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

   322     Document* doc = m_frame->document();

   323 

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

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

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

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

   328     

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

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

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

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

   333         

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

   335     RenderPart* frameRenderer = m_frame->ownerRenderer();

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

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

   338     

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

   340     return ScrollView::createScrollbar(orientation);

   341 }

   342 

   343 void FrameView::setContentsSize(const IntSize& size)

   344 {

   345     m_deferSetNeedsLayouts++;

   346 

   347     ScrollView::setContentsSize(size);

   348 

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

   350     if (!page)

   351         return;

   352 

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

   354     

   355     m_deferSetNeedsLayouts--;

   356     

   357     if (!m_deferSetNeedsLayouts)

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

   359 }

   360 

   361 void FrameView::adjustViewSize()

   362 {

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

   364     RenderView* root = m_frame->contentRenderer();

   365     if (!root)

   366         return;

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

   368 }

   369 

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

   371 {

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

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

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

   375     // use the root element.

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

   377         case OHIDDEN:

   378             hMode = ScrollbarAlwaysOff;

   379             break;

   380         case OSCROLL:

   381             hMode = ScrollbarAlwaysOn;

   382             break;

   383         case OAUTO:

   384             hMode = ScrollbarAuto;

   385             break;

   386         default:

   387             // Don't set it at all.

   388             ;

   389     }

   390     

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

   392         case OHIDDEN:

   393             vMode = ScrollbarAlwaysOff;

   394             break;

   395         case OSCROLL:

   396             vMode = ScrollbarAlwaysOn;

   397             break;

   398         case OAUTO:

   399             vMode = ScrollbarAuto;

   400             break;

   401         default:

   402             // Don't set it at all.

   403             ;

   404     }

   405 

   406     m_viewportRenderer = o;

   407 }

   408 

   409 #if USE(ACCELERATED_COMPOSITING)

   410 void FrameView::updateCompositingLayers()

   411 {

   412     RenderView* view = m_frame->contentRenderer();

   413     if (!view)

   414         return;

   415 

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

   417     view->compositor()->cacheAcceleratedCompositingEnabledFlag();

   418     

   419     if (!view->usesCompositing())

   420         return;

   421 

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

   423 }

   424 

   425 void FrameView::setNeedsOneShotDrawingSynchronization()

   426 {

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

   428     if (page)

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

   430 }

   431 #endif // USE(ACCELERATED_COMPOSITING)

   432 

   433 bool FrameView::syncCompositingStateRecursive()

   434 {

   435 #if USE(ACCELERATED_COMPOSITING)

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

   437     RenderView* contentRenderer = m_frame->contentRenderer();

   438     if (!contentRenderer)

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

   440 

   441     if (m_layoutTimer.isActive()) {

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

   443         return false;

   444     }

   445     

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

   447         rootLayer->syncCompositingState();

   448 

   449     bool allSubframesSynced = true;

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

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

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

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

   454         if (widget->isFrameView()) {

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

   456             allSubframesSynced &= synced;

   457         }

   458     }

   459     return allSubframesSynced;

   460 #endif // USE(ACCELERATED_COMPOSITING)

   461     return true;

   462 }

   463 

   464 void FrameView::didMoveOnscreen()

   465 {

   466     RenderView* view = m_frame->contentRenderer();

   467     if (view)

   468         view->didMoveOnscreen();

   469 }

   470 

   471 void FrameView::willMoveOffscreen()

   472 {

   473     RenderView* view = m_frame->contentRenderer();

   474     if (view)

   475         view->willMoveOffscreen();

   476 }

   477 

   478 RenderObject* FrameView::layoutRoot(bool onlyDuringLayout) const

   479 {

   480     return onlyDuringLayout && layoutPending() ? 0 : m_layoutRoot;

   481 }

   482 

   483 void FrameView::layout(bool allowSubtree)

   484 {

   485     if (m_midLayout)

   486         return;

   487 

   488     m_layoutTimer.stop();

   489     m_delayedLayout = false;

   490     m_setNeedsLayoutWasDeferred = false;

   491 

   492     // Protect the view from being deleted during layout (in recalcStyle)

   493     RefPtr<FrameView> protector(this);

   494 

   495     if (!m_frame) {

   496         // FIXME: Do we need to set m_size.width here?

   497         // FIXME: Should we set m_size.height here too?

   498         m_size.setWidth(layoutWidth());

   499         return;

   500     }

   501     

   502     // we shouldn't enter layout() while painting

   503     ASSERT(!isPainting());

   504     if (isPainting())

   505         return;

   506 

   507 #if ENABLE(INSPECTOR)

   508     InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent();

   509     if (timelineAgent)

   510         timelineAgent->willLayout();

   511 #endif

   512 

   513     if (!allowSubtree && m_layoutRoot) {

   514         m_layoutRoot->markContainingBlocksForLayout(false);

   515         m_layoutRoot = 0;

   516     }

   517 

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

   519     // This early return should be removed when rdar://5598072 is resolved. In the meantime, there is a

   520     // gigantic CrashTracer because of this issue, and the early return will hopefully cause graceful 

   521     // failure instead.  

   522     if (m_frame->view() != this)

   523         return;

   524 

   525     Document* document = m_frame->document();

   526 

   527     m_layoutSchedulingEnabled = false;

   528 

   529     if (!m_nestedLayoutCount && m_postLayoutTasksTimer.isActive()) {

   530         // This is a new top-level layout. If there are any remaining tasks from the previous

   531         // layout, finish them now.

   532         m_postLayoutTasksTimer.stop();

   533         performPostLayoutTasks();

   534     }

   535 

   536     // Viewport-dependent media queries may cause us to need completely different style information.

   537     // Check that here.

   538     if (document->styleSelector()->affectedByViewportChange())

   539         document->updateStyleSelector();

   540 

   541     // Always ensure our style info is up-to-date.  This can happen in situations where

   542     // the layout beats any sort of style recalc update that needs to occur.

   543     if (m_frame->needsReapplyStyles())

   544         m_frame->reapplyStyles();

   545     else if (document->childNeedsStyleRecalc())

   546         document->recalcStyle();

   547     

   548     bool subtree = m_layoutRoot;

   549 

   550     // If there is only one ref to this view left, then its going to be destroyed as soon as we exit, 

   551     // so there's no point to continuing to layout

   552     if (protector->hasOneRef())

   553         return;

   554 

   555     RenderObject* root = subtree ? m_layoutRoot : document->renderer();

   556     if (!root) {

   557         // FIXME: Do we need to set m_size here?

   558         m_layoutSchedulingEnabled = true;

   559         return;

   560     }

   561 

   562     m_nestedLayoutCount++;

   563 

   564     ScrollbarMode hMode;

   565     ScrollbarMode vMode;

   566     scrollbarModes(hMode, vMode);

   567 

   568     if (!subtree) {

   569         RenderObject* rootRenderer = document->documentElement() ? document->documentElement()->renderer() : 0;

   570         Node* body = document->body();

   571         if (body && body->renderer()) {

   572             if (body->hasTagName(framesetTag)) {

   573                 body->renderer()->setChildNeedsLayout(true);

   574                 vMode = ScrollbarAlwaysOff;

   575                 hMode = ScrollbarAlwaysOff;

   576             } else if (body->hasTagName(bodyTag)) {

   577                 if (!m_firstLayout && m_size.height() != layoutHeight()

   578                         && toRenderBox(body->renderer())->stretchesToViewHeight())

   579                     body->renderer()->setChildNeedsLayout(true);

   580                 // It's sufficient to just check the X overflow,

   581                 // since it's illegal to have visible in only one direction.

   582                 RenderObject* o = rootRenderer->style()->overflowX() == OVISIBLE && document->documentElement()->hasTagName(htmlTag) ? body->renderer() : rootRenderer;

   583                 applyOverflowToViewport(o, hMode, vMode);

   584             }

   585         } else if (rootRenderer)

   586             applyOverflowToViewport(rootRenderer, hMode, vMode);

   587 #ifdef INSTRUMENT_LAYOUT_SCHEDULING

   588         if (m_firstLayout && !document->ownerElement())

   589             printf("Elapsed time before first layout: %d\n", document->elapsedTime());

   590 #endif

   591     }

   592 

   593     m_doFullRepaint = !subtree && (m_firstLayout || toRenderView(root)->printing());

   594 

   595     if (!subtree) {

   596         // Now set our scrollbar state for the layout.

   597         ScrollbarMode currentHMode = horizontalScrollbarMode();

   598         ScrollbarMode currentVMode = verticalScrollbarMode();

   599 

   600         if (m_firstLayout || (hMode != currentHMode || vMode != currentVMode)) {

   601             setScrollbarsSuppressed(true);

   602             if (m_firstLayout) {

   603                 m_firstLayout = false;

   604                 m_firstLayoutCallbackPending = true;

   605                 m_lastLayoutSize = IntSize(width(), height());

   606                 m_lastZoomFactor = root->style()->zoom();

   607 

   608                 // Set the initial vMode to AlwaysOn if we're auto.

   609                 if (vMode == ScrollbarAuto)

   610                     setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.

   611                 // Set the initial hMode to AlwaysOff if we're auto.

   612                 if (hMode == ScrollbarAuto)

   613                     setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.

   614             }

   615             setScrollbarModes(hMode, vMode);

   616             setScrollbarsSuppressed(false, true);

   617         }

   618 

   619         IntSize oldSize = m_size;

   620 

   621         m_size = IntSize(layoutWidth(), layoutHeight());

   622 

   623         if (oldSize != m_size)

   624             m_doFullRepaint = true;

   625     }

   626 

   627     RenderLayer* layer = root->enclosingLayer();

   628 

   629     pauseScheduledEvents();

   630 

   631     if (subtree)

   632         root->view()->pushLayoutState(root);

   633         

   634     m_midLayout = true;

   635     beginDeferredRepaints();

   636     root->layout();

   637     endDeferredRepaints();

   638     m_midLayout = false;

   639 

   640     if (subtree)

   641         root->view()->popLayoutState();

   642     m_layoutRoot = 0;

   643 

   644     m_frame->invalidateSelection();

   645    

   646     m_layoutSchedulingEnabled = true;

   647 

   648     if (!subtree && !toRenderView(root)->printing())

   649         adjustViewSize();

   650 

   651     // Now update the positions of all layers.

   652     beginDeferredRepaints();

   653     layer->updateLayerPositions((m_doFullRepaint ? RenderLayer::DoFullRepaint : 0)

   654                                 | RenderLayer::CheckForRepaint

   655                                 | RenderLayer::IsCompositingUpdateRoot

   656                                 | RenderLayer::UpdateCompositingLayers);

   657     endDeferredRepaints();

   658 

   659 #if USE(ACCELERATED_COMPOSITING)

   660     updateCompositingLayers();

   661 #endif

   662     

   663     m_layoutCount++;

   664 

   665 #if PLATFORM(MAC)

   666     if (AXObjectCache::accessibilityEnabled())

   667         root->document()->axObjectCache()->postNotification(root, AXObjectCache::AXLayoutComplete, true);

   668 #endif

   669 #if ENABLE(DASHBOARD_SUPPORT)

   670     updateDashboardRegions();

   671 #endif

   672 

   673     ASSERT(!root->needsLayout());

   674 

   675     setCanBlitOnScroll(!useSlowRepaints());

   676 

   677     if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))

   678         updateOverflowStatus(layoutWidth() < contentsWidth(),

   679                              layoutHeight() < contentsHeight());

   680 

   681     if (!m_postLayoutTasksTimer.isActive()) {

   682         // Calls resumeScheduledEvents()

   683         performPostLayoutTasks();

   684 

   685         if (!m_postLayoutTasksTimer.isActive() && needsLayout()) {

   686             // Post-layout widget updates or an event handler made us need layout again.

   687             // Lay out again, but this time defer widget updates and event dispatch until after

   688             // we return.

   689             m_postLayoutTasksTimer.startOneShot(0);

   690             pauseScheduledEvents();

   691             layout();

   692         }

   693     } else {

   694         resumeScheduledEvents();

   695         ASSERT(m_enqueueEvents);

   696     }

   697 

   698 #if ENABLE(INSPECTOR)

   699     if (timelineAgent)

   700         timelineAgent->didLayout();

   701 #endif

   702 

   703     m_nestedLayoutCount--;

   704 }

   705 

   706 void FrameView::addWidgetToUpdate(RenderPartObject* object)

   707 {

   708     if (!m_widgetUpdateSet)

   709         m_widgetUpdateSet.set(new HashSet<RenderPartObject*>);

   710 

   711     m_widgetUpdateSet->add(object);

   712 }

   713 

   714 void FrameView::removeWidgetToUpdate(RenderPartObject* object)

   715 {

   716     if (!m_widgetUpdateSet)

   717         return;

   718 

   719     m_widgetUpdateSet->remove(object);

   720 }

   721 

   722 void FrameView::setMediaType(const String& mediaType)

   723 {

   724     m_mediaType = mediaType;

   725 }

   726 

   727 String FrameView::mediaType() const

   728 {

   729     // See if we have an override type.

   730     String overrideType = m_frame->loader()->client()->overrideMediaType();

   731     if (!overrideType.isNull())

   732         return overrideType;

   733     return m_mediaType;

   734 }

   735 

   736 bool FrameView::useSlowRepaints() const

   737 {

   738     return m_useSlowRepaints || m_slowRepaintObjectCount > 0 || m_isOverlapped || !m_contentIsOpaque;

   739 }

   740 

   741 void FrameView::setUseSlowRepaints()

   742 {

   743     m_useSlowRepaints = true;

   744     setCanBlitOnScroll(false);

   745 }

   746 

   747 void FrameView::addSlowRepaintObject()

   748 {

   749     if (!m_slowRepaintObjectCount)

   750         setCanBlitOnScroll(false);

   751     m_slowRepaintObjectCount++;

   752 }

   753 

   754 void FrameView::removeSlowRepaintObject()

   755 {

   756     ASSERT(m_slowRepaintObjectCount > 0);

   757     m_slowRepaintObjectCount--;

   758     if (!m_slowRepaintObjectCount)

   759         setCanBlitOnScroll(!useSlowRepaints());

   760 }

   761 

   762 void FrameView::setIsOverlapped(bool isOverlapped)

   763 {

   764     if (isOverlapped == m_isOverlapped)

   765         return;

   766 

   767     m_isOverlapped = isOverlapped;

   768     setCanBlitOnScroll(!useSlowRepaints());

   769 }

   770 

   771 void FrameView::setContentIsOpaque(bool contentIsOpaque)

   772 {

   773     if (contentIsOpaque == m_contentIsOpaque)

   774         return;

   775 

   776     m_contentIsOpaque = contentIsOpaque;

   777     setCanBlitOnScroll(!useSlowRepaints());

   778 }

   779 

   780 void FrameView::restoreScrollbar()

   781 {

   782     setScrollbarsSuppressed(false);

   783 }

   784 

   785 bool FrameView::scrollToFragment(const KURL& url)

   786 {

   787     // If our URL has no ref, then we have no place we need to jump to.

   788     // OTOH If CSS target was set previously, we want to set it to 0, recalc

   789     // and possibly repaint because :target pseudo class may have been

   790     // set (see bug 11321).

   791     if (!url.hasFragmentIdentifier() && !m_frame->document()->cssTarget())

   792         return false;

   793 

   794     String fragmentIdentifier = url.fragmentIdentifier();

   795     if (scrollToAnchor(fragmentIdentifier))

   796         return true;

   797 

   798     // Try again after decoding the ref, based on the document's encoding.

   799     if (TextResourceDecoder* decoder = m_frame->document()->decoder())

   800         return scrollToAnchor(decodeURLEscapeSequences(fragmentIdentifier, decoder->encoding()));

   801 

   802     return false;

   803 }

   804 

   805 bool FrameView::scrollToAnchor(const String& name)

   806 {

   807     ASSERT(m_frame->document());

   808 

   809     if (!m_frame->document()->haveStylesheetsLoaded()) {

   810         m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(true);

   811         return false;

   812     }

   813 

   814     m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(false);

   815 

   816     Element* anchorNode = m_frame->document()->findAnchor(name);

   817 

   818 #if ENABLE(SVG)

   819     if (m_frame->document()->isSVGDocument()) {

   820         if (name.startsWith("xpointer(")) {

   821             // We need to parse the xpointer reference here

   822         } else if (name.startsWith("svgView(")) {

   823             RefPtr<SVGSVGElement> svg = static_cast<SVGDocument*>(m_frame->document())->rootElement();

   824             if (!svg->currentView()->parseViewSpec(name))

   825                 return false;

   826             svg->setUseCurrentView(true);

   827         } else {

   828             if (anchorNode && anchorNode->hasTagName(SVGNames::viewTag)) {

   829                 RefPtr<SVGViewElement> viewElement = anchorNode->hasTagName(SVGNames::viewTag) ? static_cast<SVGViewElement*>(anchorNode) : 0;

   830                 if (viewElement.get()) {

   831                     RefPtr<SVGSVGElement> svg = static_cast<SVGSVGElement*>(SVGLocatable::nearestViewportElement(viewElement.get()));

   832                     svg->inheritViewAttributes(viewElement.get());

   833                 }

   834             }

   835         }

   836         // FIXME: need to decide which <svg> to focus on, and zoom to that one

   837         // FIXME: need to actually "highlight" the viewTarget(s)

   838     }

   839 #endif

   840 

   841     m_frame->document()->setCSSTarget(anchorNode); // Setting to null will clear the current target.

   842   

   843     // Implement the rule that "" and "top" both mean top of page as in other browsers.

   844     if (!anchorNode && !(name.isEmpty() || equalIgnoringCase(name, "top")))

   845         return false;

   846 

   847     maintainScrollPositionAtAnchor(anchorNode ? static_cast<Node*>(anchorNode) : m_frame->document());

   848     return true;

   849 }

   850 

   851 void FrameView::maintainScrollPositionAtAnchor(Node* anchorNode)

   852 {

   853     m_maintainScrollPositionAnchor = anchorNode;

   854     if (!m_maintainScrollPositionAnchor)

   855         return;

   856 

   857     // We need to update the layout before scrolling, otherwise we could

   858     // really mess things up if an anchor scroll comes at a bad moment.

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

   860     // Only do a layout if changes have occurred that make it necessary.

   861     if (m_frame->contentRenderer() && m_frame->contentRenderer()->needsLayout())

   862         layout();

   863     else

   864         scrollToAnchor();

   865 }

   866 

   867 void FrameView::scrollRectIntoViewRecursively(const IntRect& r)

   868 {

   869     bool wasInProgrammaticScroll = m_inProgrammaticScroll;

   870     m_inProgrammaticScroll = true;

   871     m_maintainScrollPositionAnchor = 0;

   872     ScrollView::scrollRectIntoViewRecursively(r);

   873     m_inProgrammaticScroll = wasInProgrammaticScroll;

   874 }

   875 

   876 void FrameView::setScrollPosition(const IntPoint& scrollPoint)

   877 {

   878     bool wasInProgrammaticScroll = m_inProgrammaticScroll;

   879     m_inProgrammaticScroll = true;

   880     m_maintainScrollPositionAnchor = 0;

   881     ScrollView::setScrollPosition(scrollPoint);

   882     m_inProgrammaticScroll = wasInProgrammaticScroll;

   883 }

   884 

   885 void FrameView::scrollPositionChanged()

   886 {

   887     frame()->eventHandler()->sendScrollEvent();

   888 

   889 #if USE(ACCELERATED_COMPOSITING)

   890     // We need to update layer positions after scrolling to account for position:fixed layers.

   891     Document* document = m_frame->document();

   892     if (!document)

   893         return;

   894 

   895     RenderLayer* layer = document->renderer() ? document->renderer()->enclosingLayer() : 0;

   896     if (layer)

   897         layer->updateLayerPositions(RenderLayer::UpdateCompositingLayers);

   898 #endif

   899 }

   900 

   901 HostWindow* FrameView::hostWindow() const

   902 {

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

   904     if (!page)

   905         return 0;

   906     return page->chrome();

   907 }

   908 

   909 const unsigned cRepaintRectUnionThreshold = 25;

   910 

   911 void FrameView::repaintContentRectangle(const IntRect& r, bool immediate)

   912 {

   913     ASSERT(!m_frame->document()->ownerElement());

   914 

   915     double delay = adjustedDeferredRepaintDelay();

   916     if ((m_deferringRepaints || m_deferredRepaintTimer.isActive() || delay) && !immediate) {

   917         IntRect visibleContent = visibleContentRect();

   918         visibleContent.intersect(r);

   919         if (visibleContent.isEmpty())

   920             return;

   921         if (m_repaintCount == cRepaintRectUnionThreshold) {

   922             IntRect unionedRect;

   923             for (unsigned i = 0; i < cRepaintRectUnionThreshold; ++i)

   924                 unionedRect.unite(m_repaintRects[i]);

   925             m_repaintRects.clear();

   926             m_repaintRects.append(unionedRect);

   927         }

   928         if (m_repaintCount < cRepaintRectUnionThreshold)

   929             m_repaintRects.append(visibleContent);

   930         else

   931             m_repaintRects[0].unite(visibleContent);

   932         m_repaintCount++;

   933     

   934         if (!m_deferringRepaints && !m_deferredRepaintTimer.isActive())

   935              m_deferredRepaintTimer.startOneShot(delay);

   936         return;

   937     }

   938     

   939     if (!immediate && isOffscreen() && !shouldUpdateWhileOffscreen())

   940         return;

   941 

   942     ScrollView::repaintContentRectangle(r, immediate);

   943 }

   944 

   945 void FrameView::visibleContentsResized()

   946 {

   947     // We check to make sure the view is attached to a frame() as this method can

   948     // be triggered before the view is attached by Frame::createView(...) setting

   949     // various values such as setScrollBarModes(...) for example.  An ASSERT is

   950     // triggered when a view is layout before being attached to a frame().

   951     if (!frame()->view())

   952         return;

   953 

   954     if (needsLayout())

   955         layout();

   956 }

   957 

   958 void FrameView::beginDeferredRepaints()

   959 {

   960     Page* page = m_frame->page();

   961     if (page->mainFrame() != m_frame)

   962         return page->mainFrame()->view()->beginDeferredRepaints();

   963 

   964     m_deferringRepaints++;

   965 }

   966 

   967 

   968 void FrameView::endDeferredRepaints()

   969 {

   970     Page* page = m_frame->page();

   971     if (page->mainFrame() != m_frame)

   972         return page->mainFrame()->view()->endDeferredRepaints();

   973 

   974     ASSERT(m_deferringRepaints > 0);

   975 

   976     if (--m_deferringRepaints)

   977         return;

   978     

   979     if (m_deferredRepaintTimer.isActive())

   980         return;

   981 

   982     if (double delay = adjustedDeferredRepaintDelay()) {

   983         m_deferredRepaintTimer.startOneShot(delay);

   984         return;

   985     }

   986     

   987     doDeferredRepaints();

   988 }

   989 

   990 void FrameView::checkStopDelayingDeferredRepaints()

   991 {

   992     if (!m_deferredRepaintTimer.isActive())

   993         return;

   994 

   995     Document* document = m_frame->document();

   996     if (document && (document->parsing() || document->docLoader()->requestCount()))

   997         return;

   998     

   999     m_deferredRepaintTimer.stop();

  1000 

  1001     doDeferredRepaints();

  1002 }

  1003     

  1004 void FrameView::doDeferredRepaints()

  1005 {

  1006     ASSERT(!m_deferringRepaints);

  1007     if (isOffscreen() && !shouldUpdateWhileOffscreen()) {

  1008         m_repaintRects.clear();

  1009         m_repaintCount = 0;

  1010         return;

  1011     }

  1012     unsigned size = m_repaintRects.size();

  1013     for (unsigned i = 0; i < size; i++)

  1014         ScrollView::repaintContentRectangle(m_repaintRects[i], false);

  1015     m_repaintRects.clear();

  1016     m_repaintCount = 0;

  1017     

  1018     updateDeferredRepaintDelay();

  1019 }

  1020 

  1021 void FrameView::updateDeferredRepaintDelay()

  1022 {

  1023     Document* document = m_frame->document();

  1024     if (!document || (!document->parsing() && !document->docLoader()->requestCount())) {

  1025         m_deferredRepaintDelay = deferredRepaintDelay;

  1026         return;

  1027     }

  1028     if (m_deferredRepaintDelay < maxDeferredRepaintDelayDuringLoading) {

  1029         m_deferredRepaintDelay += deferredRepaintDelayIncrementDuringLoading;

  1030         if (m_deferredRepaintDelay > maxDeferredRepaintDelayDuringLoading)

  1031             m_deferredRepaintDelay = maxDeferredRepaintDelayDuringLoading;

  1032     }

  1033 }

  1034 

  1035 void FrameView::resetDeferredRepaintDelay()

  1036 {

  1037     m_deferredRepaintDelay = 0;

  1038     if (m_deferredRepaintTimer.isActive()) {

  1039         m_deferredRepaintTimer.stop();

  1040         if (!m_deferringRepaints)

  1041             doDeferredRepaints();

  1042     }

  1043 }

  1044 

  1045 double FrameView::adjustedDeferredRepaintDelay() const

  1046 {

  1047     if (!m_deferredRepaintDelay)

  1048         return 0;

  1049     double timeSinceLastPaint = currentTime() - m_lastPaintTime;

  1050     return max(0., m_deferredRepaintDelay - timeSinceLastPaint);

  1051 }

  1052     

  1053 void FrameView::deferredRepaintTimerFired(Timer<FrameView>*)

  1054 {

  1055     doDeferredRepaints();

  1056 }    

  1057 

  1058 void FrameView::layoutTimerFired(Timer<FrameView>*)

  1059 {

  1060 #ifdef INSTRUMENT_LAYOUT_SCHEDULING

  1061     if (!m_frame->document()->ownerElement())

  1062         printf("Layout timer fired at %d\n", m_frame->document()->elapsedTime());

  1063 #endif

  1064     layout();

  1065 }

  1066 

  1067 void FrameView::scheduleRelayout()

  1068 {

  1069     // FIXME: We should assert the page is not in the page cache, but that is causing

  1070     // too many false assertions.  See <rdar://problem/7218118>.

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

  1072 

  1073     if (m_layoutRoot) {

  1074         m_layoutRoot->markContainingBlocksForLayout(false);

  1075         m_layoutRoot = 0;

  1076     }

  1077     if (!m_layoutSchedulingEnabled)

  1078         return;

  1079     if (!needsLayout())

  1080         return;

  1081     if (!m_frame->document()->shouldScheduleLayout())

  1082         return;

  1083 

  1084     int delay = m_frame->document()->minimumLayoutDelay();

  1085     if (m_layoutTimer.isActive() && m_delayedLayout && !delay)

  1086         unscheduleRelayout();

  1087     if (m_layoutTimer.isActive())

  1088         return;

  1089 

  1090     m_delayedLayout = delay != 0;

  1091 

  1092 #ifdef INSTRUMENT_LAYOUT_SCHEDULING

  1093     if (!m_frame->document()->ownerElement())

  1094         printf("Scheduling layout for %d\n", delay);

  1095 #endif

  1096 

  1097     m_layoutTimer.startOneShot(delay * 0.001);

  1098 }

  1099 

  1100 static bool isObjectAncestorContainerOf(RenderObject* ancestor, RenderObject* descendant)

  1101 {

  1102     for (RenderObject* r = descendant; r; r = r->container()) {

  1103         if (r == ancestor)

  1104             return true;

  1105     }

  1106     return false;

  1107 }

  1108 

  1109 void FrameView::scheduleRelayoutOfSubtree(RenderObject* relayoutRoot)

  1110 {

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

  1112 

  1113     if (!m_layoutSchedulingEnabled || (m_frame->contentRenderer()

  1114             && m_frame->contentRenderer()->needsLayout())) {

  1115         if (relayoutRoot)

  1116             relayoutRoot->markContainingBlocksForLayout(false);

  1117         return;

  1118     }

  1119 

  1120     if (layoutPending()) {

  1121         if (m_layoutRoot != relayoutRoot) {

  1122             if (isObjectAncestorContainerOf(m_layoutRoot, relayoutRoot)) {

  1123                 // Keep the current root

  1124                 relayoutRoot->markContainingBlocksForLayout(false, m_layoutRoot);

  1125             } else if (m_layoutRoot && isObjectAncestorContainerOf(relayoutRoot, m_layoutRoot)) {

  1126                 // Re-root at relayoutRoot

  1127                 m_layoutRoot->markContainingBlocksForLayout(false, relayoutRoot);

  1128                 m_layoutRoot = relayoutRoot;

  1129             } else {

  1130                 // Just do a full relayout

  1131                 if (m_layoutRoot)

  1132                     m_layoutRoot->markContainingBlocksForLayout(false);

  1133                 m_layoutRoot = 0;

  1134                 relayoutRoot->markContainingBlocksForLayout(false);