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 "Chrome.h"

    33 #include "ChromeClient.h"

    34 #include "DocLoader.h"

    35 #include "EventHandler.h"

    36 #include "FloatRect.h"

    37 #include "FocusController.h"

    38 #include "Frame.h"

    39 #include "FrameLoader.h"

    40 #include "FrameLoaderClient.h"

    41 #include "FrameTree.h"

    42 #include "GraphicsContext.h"

    43 #include "HTMLDocument.h"

    44 #include "HTMLFrameElement.h"

    45 #include "HTMLFrameSetElement.h"

    46 #include "HTMLNames.h"

    47 #include "InspectorTimelineAgent.h"

    48 #include "OverflowEvent.h"

    49 #include "RenderEmbeddedObject.h"

    50 #include "RenderLayer.h"

    51 #include "RenderPart.h"

    52 #include "RenderScrollbar.h"

    53 #include "RenderScrollbarPart.h"

    54 #include "RenderTheme.h"

    55 #include "RenderView.h"

    56 #include "Settings.h"

    57 #include "TextResourceDecoder.h"

    58 #include <wtf/CurrentTime.h>

    59 

    60 #if USE(ACCELERATED_COMPOSITING)

    61 #include "RenderLayerCompositor.h"

    62 #endif

    63 

    64 #if ENABLE(SVG)

    65 #include "SVGDocument.h"

    66 #include "SVGLocatable.h"

    67 #include "SVGNames.h"

    68 #include "SVGPreserveAspectRatio.h"

    69 #include "SVGSVGElement.h"

    70 #include "SVGViewElement.h"

    71 #include "SVGViewSpec.h"

    72 #endif

    73 

    74 #if ENABLE(TILED_BACKING_STORE)

    75 #include "TiledBackingStore.h"

    76 #endif

    77 

    78 namespace WebCore {

    79 

    80 using namespace HTMLNames;

    81 

    82 double FrameView::sCurrentPaintTimeStamp = 0.0;

    83 

    84 // REPAINT_THROTTLING now chooses default values for throttling parameters.

    85 // Should be removed when applications start using runtime configuration.

    86 #if ENABLE(REPAINT_THROTTLING)

    87 // Normal delay

    88 double FrameView::s_deferredRepaintDelay = 0.025;

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

    90 double FrameView::s_initialDeferredRepaintDelayDuringLoading = 0;

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

    92 double FrameView::s_maxDeferredRepaintDelayDuringLoading = 2.5;

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

    94 double FrameView::s_deferredRepaintDelayIncrementDuringLoading = 0.5;

    95 #else

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

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

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

    99 double FrameView::s_deferredRepaintDelay = 0;

   100 double FrameView::s_initialDeferredRepaintDelayDuringLoading = 0;

   101 double FrameView::s_maxDeferredRepaintDelayDuringLoading = 0;

   102 double FrameView::s_deferredRepaintDelayIncrementDuringLoading = 0;

   103 #endif

   104 

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

   106 static const unsigned maxUpdateWidgetsIterations = 2;

   107 

   108 struct ScheduledEvent : Noncopyable {

   109     RefPtr<Event> m_event;

   110     RefPtr<Node> m_eventTarget;

   111 };

   112 

   113 static inline float parentZoomFactor(Frame* frame)

   114 {

   115     Frame* parent = frame->tree()->parent();

   116     if (!parent)

   117         return 1;

   118     FrameView* parentView = parent->view();

   119     if (!parentView)

   120         return 1;

   121     return parentView->zoomFactor();

   122 }

   123 

   124 FrameView::FrameView(Frame* frame)

   125     : m_frame(frame)

   126     , m_canHaveScrollbars(true)

   127     , m_slowRepaintObjectCount(0)

   128     , m_fixedObjectCount(0)

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

   130     , m_layoutRoot(0)

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

   132     , m_isTransparent(false)

   133     , m_baseBackgroundColor(Color::white)

   134     , m_mediaType("screen")

   135     , m_enqueueEvents(0)

   136     , m_overflowStatusDirty(true)

   137     , m_viewportRenderer(0)

   138     , m_wasScrolledByUser(false)

   139     , m_inProgrammaticScroll(false)

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

   141     , m_shouldUpdateWhileOffscreen(true)

   142     , m_deferSetNeedsLayouts(0)

   143     , m_setNeedsLayoutWasDeferred(false)

   144     , m_scrollCorner(0)

   145     , m_zoomFactor(parentZoomFactor(frame))

   146 {

   147     init();

   148 }

   149 

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

   151 {

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

   153     view->show();

   154     return view.release();

   155 }

   156 

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

   158 {

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

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

   161     view->show();

   162     return view.release();

   163 }

   164 

   165 FrameView::~FrameView()

   166 {

   167     if (m_postLayoutTasksTimer.isActive()) {

   168         m_postLayoutTasksTimer.stop();

   169         m_scheduledEvents.clear();

   170         m_enqueueEvents = 0;

   171     }

   172 

   173     resetScrollbars();

   174 

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

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

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

   178 

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

   180     setHasVerticalScrollbar(false);

   181     

   182     ASSERT(!m_scrollCorner);

   183     ASSERT(m_scheduledEvents.isEmpty());

   184     ASSERT(!m_enqueueEvents);

   185 

   186     if (m_frame) {

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

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

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

   190             renderer->setWidget(0);

   191     }

   192 }

   193 

   194 void FrameView::reset()

   195 {

   196     m_useSlowRepaints = false;

   197     m_isOverlapped = false;

   198     m_contentIsOpaque = false;

   199     m_borderX = 30;

   200     m_borderY = 30;

   201     m_layoutTimer.stop();

   202     m_layoutRoot = 0;

   203     m_delayedLayout = false;

   204     m_doFullRepaint = true;

   205     m_layoutSchedulingEnabled = true;

   206     m_midLayout = false;

   207     m_layoutCount = 0;

   208     m_nestedLayoutCount = 0;

   209     m_postLayoutTasksTimer.stop();

   210     m_firstLayout = true;

   211     m_firstLayoutCallbackPending = false;

   212     m_wasScrolledByUser = false;

   213     m_lastLayoutSize = IntSize();

   214     m_lastZoomFactor = 1.0f;

   215     m_deferringRepaints = 0;

   216     m_repaintCount = 0;

   217     m_repaintRects.clear();

   218     m_deferredRepaintDelay = s_initialDeferredRepaintDelayDuringLoading;

   219     m_deferredRepaintTimer.stop();

   220     m_lastPaintTime = 0;

   221     m_paintBehavior = PaintBehaviorNormal;

   222     m_isPainting = false;

   223     m_isVisuallyNonEmpty = false;

   224     m_firstVisuallyNonEmptyLayoutCallbackPending = true;

   225     m_maintainScrollPositionAnchor = 0;

   226 }

   227 

   228 bool FrameView::isFrameView() const 

   229 { 

   230     return true; 

   231 }

   232 

   233 void FrameView::clearFrame()

   234 {

   235     m_frame = 0;

   236 }

   237 

   238 void FrameView::resetScrollbars()

   239 {

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

   241     m_firstLayout = true;

   242     setScrollbarsSuppressed(true);

   243     if (m_canHaveScrollbars)

   244         setScrollbarModes(ScrollbarAuto, ScrollbarAuto);

   245     else

   246         setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);

   247     setScrollbarsSuppressed(false);

   248 }

   249 

   250 void FrameView::init()

   251 {

   252     reset();

   253 

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

   255     m_size = IntSize();

   256 

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

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

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

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

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

   262             setCanHaveScrollbars(false);

   263         int marginWidth = frameElt->getMarginWidth();

   264         int marginHeight = frameElt->getMarginHeight();

   265         if (marginWidth != -1)

   266             setMarginWidth(marginWidth);

   267         if (marginHeight != -1)

   268             setMarginHeight(marginHeight);

   269     }

   270 }

   271 

   272 void FrameView::detachCustomScrollbars()

   273 {

   274     if (!m_frame)

   275         return;

   276 

   277     Scrollbar* horizontalBar = horizontalScrollbar();

   278     if (horizontalBar && horizontalBar->isCustomScrollbar())

   279         setHasHorizontalScrollbar(false);

   280 

   281     Scrollbar* verticalBar = verticalScrollbar();

   282     if (verticalBar && verticalBar->isCustomScrollbar())

   283         setHasVerticalScrollbar(false);

   284 

   285     if (m_scrollCorner) {

   286         m_scrollCorner->destroy();

   287         m_scrollCorner = 0;

   288     }

   289 }

   290 

   291 void FrameView::clear()

   292 {

   293     setCanBlitOnScroll(true);

   294     

   295     reset();

   296 

   297     if (m_frame) {

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

   299             renderer->viewCleared();

   300     }

   301 

   302     setScrollbarsSuppressed(true);

   303 }

   304 

   305 bool FrameView::didFirstLayout() const

   306 {

   307     return !m_firstLayout;

   308 }

   309 

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

   311 {

   312     if (!parent()) {

   313         if (hostWindow())

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

   315         return;

   316     }

   317 

   318     if (!m_frame)

   319         return;

   320 

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

   322     if (!renderer)

   323         return;

   324 

   325     IntRect repaintRect = rect;

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

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

   328     renderer->repaintRectangle(repaintRect);

   329 }

   330 

   331 void FrameView::setMarginWidth(int w)

   332 {

   333     // make it update the rendering area when set

   334     m_margins.setWidth(w);

   335 }

   336 

   337 void FrameView::setMarginHeight(int h)

   338 {

   339     // make it update the rendering area when set

   340     m_margins.setHeight(h);

   341 }

   342 

   343 bool FrameView::avoidScrollbarCreation()

   344 {

   345     ASSERT(m_frame);

   346 

   347     // with frame flattening no subframe can have scrollbars

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

   349     // our flattening policy using that.

   350 

   351     if (!m_frame->ownerElement())

   352         return false;

   353 

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

   355         return true;

   356 

   357     return false;

   358 }

   359 

   360 void FrameView::setCanHaveScrollbars(bool canHaveScrollbars)

   361 {

   362     m_canHaveScrollbars = canHaveScrollbars;

   363     ScrollView::setCanHaveScrollbars(canHaveScrollbars);

   364 }

   365 

   366 void FrameView::updateCanHaveScrollbars()

   367 {

   368     ScrollbarMode hMode;

   369     ScrollbarMode vMode;

   370     scrollbarModes(hMode, vMode);

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

   372         m_canHaveScrollbars = false;

   373     else

   374         m_canHaveScrollbars = true;

   375 }

   376 

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

   378 {

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

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

   381 

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

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

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

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

   386     

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

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

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

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

   391         

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

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

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

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

   396     

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

   398     return ScrollView::createScrollbar(orientation);

   399 }

   400 

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

   402 {

   403     if (size == contentsSize())

   404         return;

   405 

   406     m_deferSetNeedsLayouts++;

   407 

   408     ScrollView::setContentsSize(size);

   409 

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

   411     if (!page)

   412         return;

   413 

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

   415 

   416     m_deferSetNeedsLayouts--;

   417     

   418     if (!m_deferSetNeedsLayouts)

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

   420 }

   421 

   422 void FrameView::adjustViewSize()

   423 {

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

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

   426     if (!root)

   427         return;

   428 

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

   430 }

   431 

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

   433 {

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

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

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

   437     // use the root element.

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

   439         case OHIDDEN:

   440             hMode = ScrollbarAlwaysOff;

   441             break;

   442         case OSCROLL:

   443             hMode = ScrollbarAlwaysOn;

   444             break;

   445         case OAUTO:

   446             hMode = ScrollbarAuto;

   447             break;

   448         default:

   449             // Don't set it at all.

   450             ;

   451     }

   452     

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

   454         case OHIDDEN:

   455             vMode = ScrollbarAlwaysOff;

   456             break;

   457         case OSCROLL:

   458             vMode = ScrollbarAlwaysOn;

   459             break;

   460         case OAUTO:

   461             vMode = ScrollbarAuto;

   462             break;

   463         default:

   464             // Don't set it at all.

   465             ;

   466     }

   467 

   468     m_viewportRenderer = o;

   469 }

   470 

   471 #if USE(ACCELERATED_COMPOSITING)

   472 void FrameView::updateCompositingLayers()

   473 {

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

   475     if (!view)

   476         return;

   477 

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

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

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

   481 }

   482 

   483 void FrameView::setNeedsOneShotDrawingSynchronization()

   484 {

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

   486     if (page)

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

   488 }

   489 

   490 #endif // USE(ACCELERATED_COMPOSITING)

   491 

   492 bool FrameView::hasCompositedContent() const

   493 {

   494 #if USE(ACCELERATED_COMPOSITING)

   495     if (RenderView* view = m_frame->contentRenderer())

   496         return view->compositor()->inCompositingMode();

   497 #endif

   498     return false;

   499 }

   500 

   501 // Sometimes (for plug-ins) we need to eagerly go into compositing mode.

   502 void FrameView::enterCompositingMode()

   503 {

   504 #if USE(ACCELERATED_COMPOSITING)

   505     if (RenderView* view = m_frame->contentRenderer())

   506         view->compositor()->enableCompositingMode();

   507 #endif

   508 }

   509 

   510 bool FrameView::isEnclosedInCompositingLayer() const

   511 {

   512 #if USE(ACCELERATED_COMPOSITING)

   513     RenderObject* frameOwnerRenderer = m_frame->ownerRenderer();

   514     return frameOwnerRenderer && frameOwnerRenderer->containerForRepaint();

   515 #else

   516     return false;

   517 #endif

   518 }

   519 

   520 bool FrameView::syncCompositingStateRecursive()

   521 {

   522 #if USE(ACCELERATED_COMPOSITING)

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

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

   525     if (!contentRenderer)

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

   527 

   528     if (m_layoutTimer.isActive()) {

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

   530         return false;

   531     }

   532     

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

   534         rootLayer->syncCompositingState();

   535 

   536     bool allSubframesSynced = true;

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

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

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

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

   541         if (widget->isFrameView()) {

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

   543             allSubframesSynced &= synced;

   544         }

   545     }

   546     return allSubframesSynced;

   547 #else // USE(ACCELERATED_COMPOSITING)

   548     return true;

   549 #endif

   550 }

   551 

   552 bool FrameView::isSoftwareRenderable() const

   553 {

   554 #if USE(ACCELERATED_COMPOSITING)

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

   556     if (!view)

   557         return true;

   558 

   559     return !view->compositor()->has3DContent();

   560 #else

   561     return true;

   562 #endif

   563 }

   564 

   565 void FrameView::didMoveOnscreen()

   566 {

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

   568     if (view)

   569         view->didMoveOnscreen();

   570 }

   571 

   572 void FrameView::willMoveOffscreen()

   573 {

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

   575     if (view)

   576         view->willMoveOffscreen();

   577 }

   578 

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

   580 {

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

   582 }

   583 

   584 void FrameView::layout(bool allowSubtree)

   585 {

   586     if (m_midLayout)

   587         return;

   588 

   589     m_layoutTimer.stop();

   590     m_delayedLayout = false;

   591     m_setNeedsLayoutWasDeferred = false;

   592 

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

   594     RefPtr<FrameView> protector(this);

   595 

   596     if (!m_frame) {

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

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

   599         m_size.setWidth(layoutWidth());

   600         return;

   601     }

   602     

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

   604     ASSERT(!isPainting());

   605     if (isPainting())

   606         return;

   607 

   608 #if ENABLE(INSPECTOR)    

   609     if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())

   610         timelineAgent->willLayout();

   611 #endif

   612 

   613     if (!allowSubtree && m_layoutRoot) {

   614         m_layoutRoot->markContainingBlocksForLayout(false);

   615         m_layoutRoot = 0;

   616     }

   617 

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

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

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

   621     // failure instead.  

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

   623         return;

   624 

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

   626 

   627     m_layoutSchedulingEnabled = false;

   628 

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

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

   631         // layout, finish them now.

   632         m_postLayoutTasksTimer.stop();

   633         performPostLayoutTasks();

   634     }

   635 

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

   637     // Check that here.

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

   639         document->updateStyleSelector();

   640 

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

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

   643     if (m_frame->needsReapplyStyles())

   644         m_frame->reapplyStyles();

   645     else if (document->childNeedsStyleRecalc())

   646         document->recalcStyle();

   647     

   648     bool subtree = m_layoutRoot;

   649 

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

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

   652     if (protector->hasOneRef())

   653         return;

   654 

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

   656     if (!root) {

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

   658         m_layoutSchedulingEnabled = true;

   659         return;

   660     }

   661 

   662     m_nestedLayoutCount++;

   663 

   664     ScrollbarMode hMode;

   665     ScrollbarMode vMode;

   666     if (m_canHaveScrollbars) {

   667         hMode = ScrollbarAuto;

   668         vMode = ScrollbarAuto;

   669     } else {

   670         hMode = ScrollbarAlwaysOff;

   671         vMode = ScrollbarAlwaysOff;

   672     }

   673 

   674     if (!subtree) {

   675         Node* documentElement = document->documentElement();

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

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

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

   679             if (body->hasTagName(framesetTag) && m_frame->settings() && !m_frame->settings()->frameFlatteningEnabled()) {

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

   681                 vMode = ScrollbarAlwaysOff;

   682                 hMode = ScrollbarAlwaysOff;

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

   684                 if (!m_firstLayout && m_size.height() != layoutHeight() && body->renderer()->enclosingBox()->stretchesToViewHeight())

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

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

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

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

   689                 applyOverflowToViewport(o, hMode, vMode);

   690             }

   691         } else if (rootRenderer) {

   692 #if ENABLE(SVG)

   693             if (documentElement->isSVGElement()) {

   694                 if (!m_firstLayout && (m_size.width() != layoutWidth() || m_size.height() != layoutHeight()))

   695                     rootRenderer->setChildNeedsLayout(true);

   696             } else

   697                 applyOverflowToViewport(rootRenderer, hMode, vMode);

   698 #else

   699             applyOverflowToViewport(rootRenderer, hMode, vMode);

   700 #endif

   701         }

   702 #ifdef INSTRUMENT_LAYOUT_SCHEDULING

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

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

   705 #endif

   706     }

   707 

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

   709 

   710     if (!subtree) {

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

   712         ScrollbarMode currentHMode = horizontalScrollbarMode();

   713         ScrollbarMode currentVMode = verticalScrollbarMode();

   714 

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

   716             if (m_firstLayout) {

   717                 setScrollbarsSuppressed(true);

   718 

   719                 m_firstLayout = false;

   720                 m_firstLayoutCallbackPending = true;

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

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

   723 

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

   725                 if (vMode == ScrollbarAuto)

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

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

   728                 if (hMode == ScrollbarAuto)

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

   730 

   731                 setScrollbarModes(hMode, vMode);

   732                 setScrollbarsSuppressed(false, true);

   733             } else

   734                 setScrollbarModes(hMode, vMode);

   735         }

   736 

   737         IntSize oldSize = m_size;

   738 

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

   740 

   741         if (oldSize != m_size)

   742             m_doFullRepaint = true;

   743     }

   744 

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

   746 

   747     pauseScheduledEvents();

   748 

   749     bool disableLayoutState = false;

   750     if (subtree) {

   751         RenderView* view = root->view();

   752         disableLayoutState = view->shouldDisableLayoutStateForSubtree(root);

   753         view->pushLayoutState(root);

   754         if (disableLayoutState)

   755             view->disableLayoutState();

   756     }

   757         

   758     m_midLayout = true;

   759     beginDeferredRepaints();

   760     root->layout();

   761     endDeferredRepaints();

   762     m_midLayout = false;

   763 

   764     if (subtree) {

   765         RenderView* view = root->view();

   766         view->popLayoutState();

   767         if (disableLayoutState)

   768             view->enableLayoutState();

   769     }

   770     m_layoutRoot = 0;

   771 

   772     m_frame->selection()->setNeedsLayout();

   773     m_frame->selection()->updateAppearance();

   774    

   775     m_layoutSchedulingEnabled = true;

   776 

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

   778         adjustViewSize();

   779 

   780     // Now update the positions of all layers.

   781     beginDeferredRepaints();

   782     IntPoint cachedOffset;

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

   784                                 | RenderLayer::CheckForRepaint

   785                                 | RenderLayer::IsCompositingUpdateRoot

   786                                 | RenderLayer::UpdateCompositingLayers,

   787                                 subtree ? 0 : &cachedOffset);

   788     endDeferredRepaints();

   789 

   790 #if USE(ACCELERATED_COMPOSITING)

   791     updateCompositingLayers();

   792 #endif

   793     

   794     m_layoutCount++;

   795 

   796 #if PLATFORM(MAC)

   797     if (AXObjectCache::accessibilityEnabled())

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

   799 #endif

   800 #if ENABLE(DASHBOARD_SUPPORT)

   801     updateDashboardRegions();

   802 #endif

   803 

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

   805 

   806     setCanBlitOnScroll(!useSlowRepaints());

   807 

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

   809         updateOverflowStatus(layoutWidth() < contentsWidth(),

   810                              layoutHeight() < contentsHeight());

   811 

   812     if (!m_postLayoutTasksTimer.isActive()) {

   813         // Calls resumeScheduledEvents()

   814         performPostLayoutTasks();

   815 

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

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

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

   819             // we return.

   820             m_postLayoutTasksTimer.startOneShot(0);

   821             pauseScheduledEvents();

   822             layout();

   823         }

   824     } else {

   825         resumeScheduledEvents();

   826         ASSERT(m_enqueueEvents);

   827     }

   828 

   829 #if ENABLE(INSPECTOR)

   830     if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())

   831         timelineAgent->didLayout();

   832 #endif

   833 

   834     m_nestedLayoutCount--;

   835 }

   836 

   837 void FrameView::addWidgetToUpdate(RenderEmbeddedObject* object)

   838 {

   839     if (!m_widgetUpdateSet)

   840         m_widgetUpdateSet.set(new RenderEmbeddedObjectSet);

   841 

   842     m_widgetUpdateSet->add(object);

   843 }

   844 

   845 void FrameView::removeWidgetToUpdate(RenderEmbeddedObject* object)

   846 {

   847     if (!m_widgetUpdateSet)

   848         return;

   849 

   850     m_widgetUpdateSet->remove(object);

   851 }

   852 

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

   854 {

   855     m_mediaType = mediaType;

   856 }

   857 

   858 String FrameView::mediaType() const

   859 {

   860     // See if we have an override type.

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

   862     if (!overrideType.isNull())

   863         return overrideType;

   864     return m_mediaType;

   865 }

   866 

   867 void FrameView::adjustMediaTypeForPrinting(bool printing)

   868 {

   869     if (printing) {

   870         if (m_mediaTypeWhenNotPrinting.isNull())

   871             m_mediaTypeWhenNotPrinting = mediaType();

   872             setMediaType("print");

   873     } else {

   874         if (!m_mediaTypeWhenNotPrinting.isNull())

   875             setMediaType(m_mediaTypeWhenNotPrinting);

   876         m_mediaTypeWhenNotPrinting = String();

   877     }

   878 }

   879 

   880 bool FrameView::useSlowRepaints() const

   881 {

   882     return m_useSlowRepaints || m_slowRepaintObjectCount > 0 || (platformWidget() && m_fixedObjectCount > 0) || m_isOverlapped || !m_contentIsOpaque;

   883 }

   884 

   885 bool FrameView::useSlowRepaintsIfNotOverlapped() const

   886 {

   887     return m_useSlowRepaints || m_slowRepaintObjectCount > 0 || (platformWidget() && m_fixedObjectCount > 0) || !m_contentIsOpaque;

   888 }

   889 

   890 void FrameView::setUseSlowRepaints()

   891 {

   892     m_useSlowRepaints = true;

   893     setCanBlitOnScroll(false);

   894 }

   895 

   896 void FrameView::addSlowRepaintObject()

   897 {

   898     if (!m_slowRepaintObjectCount)

   899         setCanBlitOnScroll(false);

   900     m_slowRepaintObjectCount++;

   901 }

   902 

   903 void FrameView::removeSlowRepaintObject()

   904 {

   905     ASSERT(m_slowRepaintObjectCount > 0);

   906     m_slowRepaintObjectCount--;

   907     if (!m_slowRepaintObjectCount)

   908         setCanBlitOnScroll(!useSlowRepaints());

   909 }

   910 

   911 void FrameView::addFixedObject()

   912 {

   913     if (!m_fixedObjectCount && platformWidget())

   914         setCanBlitOnScroll(false);

   915     ++m_fixedObjectCount;

   916 }

   917 

   918 void FrameView::removeFixedObject()

   919 {

   920     ASSERT(m_fixedObjectCount > 0);

   921     --m_fixedObjectCount;

   922     if (!m_fixedObjectCount)

   923         setCanBlitOnScroll(!useSlowRepaints());

   924 }

   925 

   926 bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect)

   927 {

   928     const size_t fixedObjectThreshold = 5;

   929 

   930     RenderBlock::PositionedObjectsListHashSet* positionedObjects = 0;

   931     if (RenderView* root = m_frame->contentRenderer())

   932         positionedObjects = root->positionedObjects();

   933 

   934     if (!positionedObjects || positionedObjects->isEmpty()) {

   935         hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);

   936         return true;

   937     }

   938 

   939     // Get the rects of the fixed objects visible in the rectToScroll

   940     Vector<IntRect, fixedObjectThreshold> subRectToUpdate;

   941     bool updateInvalidatedSubRect = true;

   942     RenderBlock::PositionedObjectsListHashSet::const_iterator end = positionedObjects->end();

   943     for (RenderBlock::PositionedObjectsListHashSet::const_iterator it = positionedObjects->begin(); it != end; ++it) {

   944         RenderBox* renderBox = *it;

   945         if (renderBox->style()->position() != FixedPosition)

   946             continue;

   947         IntRect updateRect = renderBox->layer()->repaintRectIncludingDescendants();

   948         updateRect = contentsToWindow(updateRect);

   949 

   950         updateRect.intersect(rectToScroll);

   951         if (!updateRect.isEmpty()) {

   952             if (subRectToUpdate.size() >= fixedObjectThreshold) {

   953                 updateInvalidatedSubRect = false;

   954                 break;

   955             }

   956             subRectToUpdate.append(updateRect);

   957         }

   958     }

   959 

   960     // Scroll the view

   961     if (updateInvalidatedSubRect) {

   962         // 1) scroll

   963         hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);

   964 

   965         // 2) update the area of fixed objects that has been invalidated

   966         size_t fixObjectsCount = subRectToUpdate.size();

   967         for (size_t i = 0; i < fixObjectsCount; ++i) {

   968             IntRect updateRect = subRectToUpdate[i];

   969             IntRect scrolledRect = updateRect;

   970             scrolledRect.move(scrollDelta);

   971             updateRect.unite(scrolledRect);

   972             updateRect.intersect(rectToScroll);

   973             hostWindow()->invalidateContentsAndWindow(updateRect, false);

   974         }

   975         return true;

   976     }

   977 

   978     // the number of fixed objects exceed the threshold, we cannot use the fast path

   979     return false;

   980 }

   981 

   982 void FrameView::setIsOverlapped(bool isOverlapped)

   983 {

   984     if (isOverlapped == m_isOverlapped)

   985         return;

   986 

   987     m_isOverlapped = isOverlapped;

   988     setCanBlitOnScroll(!useSlowRepaints());

   989     

   990 #if USE(ACCELERATED_COMPOSITING)

   991     // Overlap can affect compositing tests, so if it changes, we need to trigger

   992     // a recalcStyle in the parent document.

   993     if (hasCompositedContent()) {

   994         if (Element* ownerElement = m_frame->document()->ownerElement())

   995             ownerElement->setNeedsStyleRecalc(SyntheticStyleChange);

   996     }

   997 #endif    

   998 }

   999 

  1000 void FrameView::setContentIsOpaque(bool contentIsOpaque)

  1001 {

  1002     if (contentIsOpaque == m_contentIsOpaque)

  1003         return;

  1004 

  1005     m_contentIsOpaque = contentIsOpaque;

  1006     setCanBlitOnScroll(!useSlowRepaints());

  1007 }

  1008 

  1009 void FrameView::restoreScrollbar()

  1010 {

  1011     setScrollbarsSuppressed(false);

  1012 }

  1013 

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

  1015 {

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

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

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

  1019     // set (see bug 11321).

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

  1021         return false;

  1022 

  1023     String fragmentIdentifier = url.fragmentIdentifier();

  1024     if (scrollToAnchor(fragmentIdentifier))

  1025         return true;

  1026 

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

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

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

  1030 

  1031     return false;

  1032 }

  1033 

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

  1035 {

  1036     ASSERT(m_frame->document());

  1037 

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

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

  1040         return false;

  1041     }

  1042 

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

  1044 

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

  1046 

  1047 #if ENABLE(SVG)

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

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

  1050             // We need to parse the xpointer reference here

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

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

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

  1054                 return false;

  1055             svg->setUseCurrentView(true);

  1056         } else {

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

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

  1059                 if (viewElement.get()) {

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

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

  1062                 }

  1063             }

  1064         }

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

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

  1067     }

  1068 #endif

  1069 

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

  1071   

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

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

  1074         return false;

  1075 

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

  1077     return true;

  1078 }

  1079 

  1080 void FrameView::maintainScrollPositionAtAnchor(Node* anchorNode)

  1081 {

  1082     m_maintainScrollPositionAnchor = anchorNode;

  1083     if (!m_maintainScrollPositionAnchor)

  1084         return;

  1085 

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

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

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

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

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

  1091         layout();

  1092     else

  1093         scrollToAnchor();

  1094 }

  1095 

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

  1097 {

  1098     bool wasInProgrammaticScroll = m_inProgrammaticScroll;

  1099     m_inProgrammaticScroll = true;

  1100     m_maintainScrollPositionAnchor = 0;

  1101     ScrollView::setScrollPosition(scrollPoint);

  1102     m_inProgrammaticScroll = wasInProgrammaticScroll;

  1103 }

  1104 

  1105 void FrameView::scrollPositionChangedViaPlatformWidget()

  1106 {

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

  1108     repaintFixedElementsAfterScrolling();

  1109 }

  1110 

  1111 void FrameView::repaintFixedElementsAfterScrolling()

  1112 {

  1113     // For fixed position elements, update widget positions and compositing layers after scrolling,

  1114     // but only if we're not inside of layout.

  1115     if (!m_nestedLayoutCount && hasFixedObjects()) {

  1116         if (RenderView* root = m_frame->contentRenderer()) {

  1117             root->updateWidgetPositions();

  1118             root->layer()->updateRepaintRectsAfterScroll();

  1119 #if USE(ACCELERATED_COMPOSITING)

  1120             root->compositor()->updateCompositingLayers(CompositingUpdateOnScroll);

  1121 #endif

  1122         }

  1123     }

  1124 

  1125 #if USE(ACCELERATED_COMPOSITING)

  1126     if (RenderView* root = m_frame->contentRenderer()) {

  1127         if (root->usesCompositing())

  1128             root->compositor()->updateContentLayerScrollPosition(scrollPosition());

  1129     }

  1130 #endif

  1131 }

  1132 

  1133 HostWindow* FrameView::hostWindow() const

  1134 {

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