Make Blink stop scheduling its own Layout, and use the compositor's timer instead

Source/core/page/FrameView.cpp

 /*
  * 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.
  *
@@ skipping 137 matching lines @@
     // is vertical, then we use TextDirection to choose between those options.
     if (writingMode == TopToBottomWritingMode || (!isHorizontalWritingMode && textDirection == RTL))
         return Pagination::TopToBottomPaginated;
     return Pagination::BottomToTopPaginated;
 }
 
 FrameView::FrameView(Frame* frame)
     : m_frame(frame)
     , m_canHaveScrollbars(true)
     , m_slowRepaintObjectCount(0)
-    , m_layoutTimer(this, &FrameView::layoutTimerFired)
+    , m_layoutIsScheduledWithEmbedder(false)
     , m_layoutRoot(0)
     , m_inSynchronousPostLayout(false)
     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
     , m_isTransparent(false)
     , m_baseBackgroundColor(Color::white)
     , m_mediaType("screen")
     , m_actionScheduler(adoptPtr(new FrameActionScheduler))
     , m_overflowStatusDirty(true)
     , m_viewportRenderer(0)
     , m_wasScrolledByUser(false)
@@ skipping 71 matching lines @@
     }
 }
 
 void FrameView::reset()
 {
     m_cannotBlitToWindow = false;
     m_isOverlapped = false;
     m_contentIsOpaque = false;
     m_borderX = 30;
     m_borderY = 30;
-    m_layoutTimer.stop();
+    unscheduleRelayout();
     m_layoutRoot = 0;
     m_delayedLayout = false;
     m_doFullRepaint = true;
     m_layoutSchedulingEnabled = true;
     m_inLayout = false;
     m_doingPreLayoutStyleUpdate = false;
     m_inSynchronousPostLayout = false;
     m_layoutCount = 0;
     m_nestedLayoutCount = 0;
     m_postLayoutTasksTimer.stop();
@@ skipping 423 matching lines @@
     }
 }
 
 void FrameView::updateCompositingLayersAfterStyleChange()
 {
     RenderView* renderView = this->renderView();
     if (!renderView)
         return;
 
     // If we expect to update compositing after an incipient layout, don't do so here.
-    if (m_doingPreLayoutStyleUpdate || layoutPending() || renderView->needsLayout())
+    if (m_doingPreLayoutStyleUpdate || layoutIsScheduledWithEmbedder() || renderView->needsLayout())
         return;
 
     // This call will make sure the cached hasAcceleratedCompositing is updated from the pref
     renderView->compositor()->cacheAcceleratedCompositingFlags();
 
     // Sometimes we will change a property (for example, z-index) that will not
     // cause a layout, but will require us to update compositing state. We only
     // need to do this if a layout is not already scheduled.
     if (!needsLayout())
         renderView->compositor()->updateCompositingRequirementsState();
@@ skipping 104 matching lines @@
 }
 
 bool FrameView::isSoftwareRenderable() const
 {
     RenderView* renderView = this->renderView();
     return !renderView || !renderView->compositor()->has3DContent();
 }
 
 RenderObject* FrameView::layoutRoot(bool onlyDuringLayout) const
 {
-    return onlyDuringLayout && layoutPending() ? 0 : m_layoutRoot;
+    return onlyDuringLayout && layoutIsScheduledWithEmbedder() ? 0 : m_layoutRoot;
 }
 
 static inline void collectFrameViewChildren(FrameView* frameView, Vector<RefPtr<FrameView> >& frameViews)
 {
     const HashSet<RefPtr<Widget> >* viewChildren = frameView->children();
     ASSERT(viewChildren);
 
     const HashSet<RefPtr<Widget> >::iterator end = viewChildren->end();
     for (HashSet<RefPtr<Widget> >::iterator current = viewChildren->begin(); current != end; ++current) {
         Widget* widget = (*current).get();
@@ skipping 45 matching lines @@
 
     TRACE_EVENT0("webkit", "FrameView::layout");
     TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "Layout");
 
     // Protect the view from being deleted during layout (in recalcStyle)
     RefPtr<FrameView> protector(this);
 
     // Every scroll that happens during layout is programmatic.
     TemporaryChange<bool> changeInProgrammaticScroll(m_inProgrammaticScroll, true);
 
-    m_layoutTimer.stop();
+    unscheduleRelayout();
     m_delayedLayout = false;
     m_setNeedsLayoutWasDeferred = false;
 
     // we shouldn't enter layout() while painting
     ASSERT(!isPainting());
     if (isPainting())
         return;
 
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willLayout(m_frame.get());
 
@@ skipping 972 matching lines @@
 {
     ASSERT(m_disableRepaints > 0);
     m_disableRepaints--;
 }
 
 void FrameView::layoutTimerFired(Timer<FrameView>*)
 {
     layout();
 }
 
+void FrameView::scheduleLayoutWithEmbedder()
+{
+    // FIXME: Right now we're hijacking the scheduleAnimation codepath.
+    scheduleAnimation();
+    m_layoutIsScheduledWithEmbedder = true;
+}
+
 void FrameView::scheduleRelayout()
 {
     ASSERT(m_frame->view() == this);
 
     if (m_layoutRoot) {
         m_layoutRoot->markContainingBlocksForLayout(false);
         m_layoutRoot = 0;
     }
     if (!m_layoutSchedulingEnabled)
         return;
     if (!needsLayout())
         return;
     if (!m_frame->document()->shouldScheduleLayout())
         return;
     InspectorInstrumentation::didInvalidateLayout(m_frame.get());
 
     // When frame seamless is enabled, the contents of the frame could affect the layout of the parent frames.
     // Also invalidate parent frame starting from the owner element of this frame.
     if (m_frame->ownerRenderer() && frame()->document()->shouldDisplaySeamlesslyWithParent())
         m_frame->ownerRenderer()->setNeedsLayout(true, MarkContainingBlockChain);
 
-    int delay = m_frame->document()->minimumLayoutDelay();
-    if (m_layoutTimer.isActive() && m_delayedLayout && !delay)
-        unscheduleRelayout();
-    if (m_layoutTimer.isActive())
-        return;
-
-    m_delayedLayout = delay != 0;
-    m_layoutTimer.startOneShot(delay * 0.001);
+    scheduleLayoutWithEmbedder();
 }
 
 static bool isObjectAncestorContainerOf(RenderObject* ancestor, RenderObject* descendant)
 {
     for (RenderObject* r = descendant; r; r = r->container()) {
         if (r == ancestor)
             return true;
     }
     return false;
 }
 
 void FrameView::scheduleRelayoutOfSubtree(RenderObject* relayoutRoot)
 {
     ASSERT(m_frame->view() == this);
 
     RenderView* renderView = this->renderView();
     if (renderView && renderView->needsLayout()) {
         if (relayoutRoot)
             relayoutRoot->markContainingBlocksForLayout(false);
         return;
     }
 
-    if (layoutPending() || !m_layoutSchedulingEnabled) {
+    if (layoutIsScheduledWithEmbedder() || !m_layoutSchedulingEnabled) {
         if (m_layoutRoot != relayoutRoot) {
             if (isObjectAncestorContainerOf(m_layoutRoot, relayoutRoot)) {
                 // Keep the current root
                 relayoutRoot->markContainingBlocksForLayout(false, m_layoutRoot);
                 ASSERT(!m_layoutRoot->container() || !m_layoutRoot->container()->needsLayout());
             } else if (m_layoutRoot && isObjectAncestorContainerOf(relayoutRoot, m_layoutRoot)) {
                 // Re-root at relayoutRoot
                 m_layoutRoot->markContainingBlocksForLayout(false, relayoutRoot);
                 m_layoutRoot = relayoutRoot;
                 ASSERT(!m_layoutRoot->container() || !m_layoutRoot->container()->needsLayout());
                 InspectorInstrumentation::didInvalidateLayout(m_frame.get());
             } else {
                 // Just do a full relayout
                 if (m_layoutRoot)
                     m_layoutRoot->markContainingBlocksForLayout(false);
                 m_layoutRoot = 0;
                 relayoutRoot->markContainingBlocksForLayout(false);
                 InspectorInstrumentation::didInvalidateLayout(m_frame.get());
             }
         }
     } else if (m_layoutSchedulingEnabled) {
         int delay = m_frame->document()->minimumLayoutDelay();
         m_layoutRoot = relayoutRoot;
         ASSERT(!m_layoutRoot->container() || !m_layoutRoot->container()->needsLayout());
         InspectorInstrumentation::didInvalidateLayout(m_frame.get());
-        m_delayedLayout = delay != 0;
-        m_layoutTimer.startOneShot(delay * 0.001);
+        scheduleLayoutWithEmbedder();
     }
 }
 
-bool FrameView::layoutPending() const
+bool FrameView::layoutIsScheduledWithEmbedder() const
 {
-    return m_layoutTimer.isActive();
+    return m_layoutIsScheduledWithEmbedder;
 }
 
 bool FrameView::needsLayout() const
 {
     // This can return true in cases where the document does not have a body yet.
     // Document::shouldScheduleLayout takes care of preventing us from scheduling
     // layout in that case.
     if (!m_frame)
         return false;
 
     RenderView* renderView = this->renderView();
-    return layoutPending()
+    return layoutIsScheduledWithEmbedder()
         || (renderView && renderView->needsLayout())
         || m_layoutRoot
         || (m_deferSetNeedsLayouts && m_setNeedsLayoutWasDeferred);
 }
 
 void FrameView::setNeedsLayout()
 {
     if (m_deferSetNeedsLayouts) {
         m_setNeedsLayoutWasDeferred = true;
         return;
     }
 
     if (RenderView* renderView = this->renderView())
         renderView->setNeedsLayout(true);
 }
 
 void FrameView::unscheduleRelayout()
 {
-    if (!m_layoutTimer.isActive())
-        return;
-
-    m_layoutTimer.stop();
-    m_delayedLayout = false;
+    // FIXME: We should just remove this method.
+    m_layoutIsScheduledWithEmbedder = false;
 }
 
 void FrameView::serviceScriptedAnimations(double monotonicAnimationStartTime)
 {
+    // The Animation timer is also used for scheduling layouts.
+    updateLayoutAndStyleIfNeededRecursive();
+
     for (RefPtr<Frame> frame = m_frame; frame; frame = frame->tree()->traverseNext()) {
         frame->view()->serviceScrollAnimations();
         if (!RuntimeEnabledFeatures::webAnimationsCSSEnabled())
             frame->animation()->serviceAnimations();
         if (RuntimeEnabledFeatures::webAnimationsEnabled())
             frame->document()->timeline()->serviceAnimations(monotonicAnimationStartTime);
     }
 
     Vector<RefPtr<Document> > documents;
     for (Frame* frame = m_frame.get(); frame; frame = frame->tree()->traverseNext())
@@ skipping 968 matching lines @@
     // layout and make sure they are up to date.
     // Mac actually tests for intersection with the dirty region and tries not to
     // update layout for frames that are outside the dirty region.  Not only does this seem
     // pointless (since those frames will have set a zero timer to layout anyway), but
     // it is also incorrect, since if two frames overlap, the first could be excluded from the dirty
     // region but then become included later by the second frame adding rects to the dirty region
     // when it lays out.
 
     m_frame->document()->updateStyleIfNeeded();
 
+    unscheduleRelayout();
     if (needsLayout())
         layout();
 
     // Grab a copy of the children() set, as it may be mutated by the following updateLayoutAndStyleIfNeededRecursive
     // calls, as they can potentially re-enter a layout of the parent frame view, which may add/remove scrollbars
     // and thus mutates the children() set.
     Vector<RefPtr<FrameView> > frameViews;
     collectFrameViewChildren(this, frameViews);
 
     const Vector<RefPtr<FrameView> >::iterator end = frameViews.end();
@@ skipping 379 matching lines @@
 }
 
 AXObjectCache* FrameView::axObjectCache() const
 {
     if (frame() && frame()->document())
         return frame()->document()->existingAXObjectCache();
     return 0;
 }
 
 } // namespace WebCore