Keep track of multiple layout roots

Source/core/frame/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 90 matching lines @@
 // The maximum number of updateWidgets iterations that should be done before returning.
 static const unsigned maxUpdateWidgetsIterations = 2;
 static const double resourcePriorityUpdateDelayAfterScroll = 0.250;
 
 FrameView::FrameView(LocalFrame* frame)
     : m_frame(frame)
     , m_displayMode(WebDisplayModeBrowser)
     , m_canHaveScrollbars(true)
     , m_slowRepaintObjectCount(0)
     , m_hasPendingLayout(false)
-    , m_layoutSubtreeRoot(0)
+    , m_isSubtreeLayout(false)
     , m_inSynchronousPostLayout(false)
     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
     , m_updateWidgetsTimer(this, &FrameView::updateWidgetsTimerFired)
     , m_isTransparent(false)
     , m_baseBackgroundColor(Color::white)
     , m_mediaType(MediaTypeNames::screen)
     , m_overflowStatusDirty(true)
     , m_viewportRenderer(0)
     , m_wasScrolledByUser(false)
     , m_inProgrammaticScroll(false)
@@ skipping 98 matching lines @@
     visitor->trace(m_horizontalScrollbar);
     visitor->trace(m_verticalScrollbar);
     visitor->trace(m_children);
 #endif
     Widget::trace(visitor);
 }
 
 void FrameView::reset()
 {
     m_hasPendingLayout = false;
-    m_layoutSubtreeRoot = nullptr;
+    m_isSubtreeLayout = false;
     m_doFullPaintInvalidation = false;
     m_layoutSchedulingEnabled = true;
     m_inPerformLayout = false;
     m_inSynchronousPostLayout = false;
     m_layoutCount = 0;
     m_nestedLayoutCount = 0;
     m_postLayoutTasksTimer.stop();
     m_updateWidgetsTimer.stop();
     m_firstLayout = true;
     m_firstLayoutCallbackPending = false;
@@ skipping 516 matching lines @@
 
 bool FrameView::isEnclosedInCompositingLayer() const
 {
     // FIXME: It's a bug that compositing state isn't always up to date when this is called. crbug.com/366314
     DisableCompositingQueryAsserts disabler;
 
     LayoutObject* frameOwnerRenderer = m_frame->ownerRenderer();
     return frameOwnerRenderer && frameOwnerRenderer->enclosingLayer()->enclosingLayerForPaintInvalidationCrossingFrameBoundaries();
 }
 
-LayoutObject* FrameView::layoutRoot(bool onlyDuringLayout) const
+static inline void countObjectsNeedingLayoutInRoot(const LayoutObject* root, unsigned& needsLayoutObjects, unsigned& totalObjects)
 {
-    return onlyDuringLayout && layoutPending() ? nullptr : m_layoutSubtreeRoot;
+    for (const LayoutObject* o = root; o; o = o->nextInPreOrder(root)) {
+        ++totalObjects;
+        if (o->needsLayout())
+            ++needsLayoutObjects;
+    }
+}
+
+void FrameView::countObjectsNeedingLayout(unsigned& needsLayoutObjects, unsigned& totalObjects, bool& isSubtree)
+{
+    needsLayoutObjects = 0;
+    totalObjects = 0;
+    if (isSubtreeLayout()) {
+        isSubtree = true;
+        for (auto& subtreeRoot : m_layoutSubtreeRoots)
+            countObjectsNeedingLayoutInRoot(subtreeRoot, needsLayoutObjects, totalObjects);
+    } else {
+        isSubtree = false;
+        countObjectsNeedingLayoutInRoot(m_frame->document()->renderView(), needsLayoutObjects, totalObjects);
+    }
+}
+
+bool FrameView::isLayoutRoot(const LayoutObject* object) const
+{
+    return m_layoutSubtreeRoots.contains(const_cast<LayoutObject*>(object));
 }
 
 inline void FrameView::forceLayoutParentViewIfNeeded()
 {
     LayoutPart* ownerRenderer = m_frame->ownerRenderer();
     if (!ownerRenderer || !ownerRenderer->frame())
         return;
 
     RenderBox* contentBox = embeddedContentBox();
     if (!contentBox)
@@ skipping 48 matching lines @@
 
     document->updateRenderTreeIfNeeded();
     lifecycle().advanceTo(DocumentLifecycle::StyleClean);
 }
 
 void FrameView::lineLayoutTime(double ms)
 {
     m_lineLayoutMs += ms;
 }
 
-void FrameView::performLayout(LayoutObject* rootForThisLayout, bool inSubtreeLayout)
+static void gatherDebugLayoutRects(LayoutObject& layoutRoot)
 {
+    bool isTracing;
+    TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("blink.debug.layout"), &isTracing);
+    if (!isTracing)
+        return;
+    if (!layoutRoot.enclosingLayer()->hasCompositedLayerMapping())
+        return;
+    // For access to compositedLayerMapping().
+    DisableCompositingQueryAsserts disabler;
+    GraphicsLayer* graphicsLayer = layoutRoot.enclosingLayer()->compositedLayerMapping()->mainGraphicsLayer();
+    if (!graphicsLayer)
+        return;
+
+    GraphicsLayerDebugInfo& debugInfo = graphicsLayer->debugInfo();
+
+    debugInfo.currentLayoutRects().clear();
+    for (LayoutObject* renderer = &layoutRoot; renderer; renderer = renderer->nextInPreOrder()) {
+        if (renderer->layoutDidGetCalledSinceLastFrame()) {
+            FloatQuad quad = renderer->localToAbsoluteQuad(FloatQuad(renderer->previousPaintInvalidationRect()));
+            LayoutRect rect = quad.enclosingBoundingBox();
+            debugInfo.currentLayoutRects().append(rect);
+        }
+    }
+}
+
+static inline void layoutFromRootObject(LayoutObject& root)
+{
+    LayoutState layoutState(root);
+    root.layout();
+    gatherDebugLayoutRects(root);
+}
+
+void FrameView::performLayout(bool inSubtreeLayout)
+{
+    ASSERT(inSubtreeLayout || m_layoutSubtreeRoots.isEmpty());
+
     m_lineLayoutMs = 0;
     TRACE_EVENT0("blink,benchmark", "FrameView::performLayout");
     double start = WTF::currentTimeMS();
 
     ScriptForbiddenScope forbidScript;
 
     ASSERT(!isInPerformLayout());
     lifecycle().advanceTo(DocumentLifecycle::InPerformLayout);
 
     TemporaryChange<bool> changeInPerformLayout(m_inPerformLayout, true);
 
     // performLayout is the actual guts of layout().
     // FIXME: The 300 other lines in layout() probably belong in other helper functions
     // so that a single human could understand what layout() is actually doing.
 
-    LayoutState layoutState(*rootForThisLayout);
-
     forceLayoutParentViewIfNeeded();
 
-    rootForThisLayout->layout();
-    gatherDebugLayoutRects(rootForThisLayout);
+    if (inSubtreeLayout) {
+        while (m_layoutSubtreeRoots.size()) {
+            LayoutObject& root = *m_layoutSubtreeRoots.takeAny();
+            if (!root.needsLayout())
+                continue;
+            layoutFromRootObject(root);
+
+            // We need to ensure that we mark up all renderers up to the RenderView
+            // for paint invalidation. This simplifies our code as we just always
+            // do a full tree walk.
+            if (LayoutObject* container = root.container())
+                container->setMayNeedPaintInvalidation();
+        }
+    } else {
+        layoutFromRootObject(*m_frame->document()->renderView());
+    }
 
     ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->updateAllImageResourcePriorities();
 
     lifecycle().advanceTo(DocumentLifecycle::AfterPerformLayout);
     int layoutMs = (WTF::currentTimeMS() - start);
     Platform::current()->histogramCustomCounts("Renderer.LayoutMs", layoutMs, 0, 1000 * 60, 50);
     // TODO(benjhayden): re-enable when safe
     // Platform::current()->histogramCustomCounts("Renderer.LineLayoutMs", m_lineLayoutMs, 0, 1000 * 60, 50);
 }
 
@@ skipping 55 matching lines @@
 
 #if !ENABLE(OILPAN)
     // If there is only one ref to this view left, then its going to be destroyed as soon as we exit,
     // so there's no point to continuing to layout
     if (protector->hasOneRef())
         return;
 #endif
 
     Document* document = m_frame->document();
     bool inSubtreeLayout = isSubtreeLayout();
-    LayoutObject* rootForThisLayout = inSubtreeLayout ? m_layoutSubtreeRoot : document->renderView();
+
+    // FIXME: The notion of a single root for layout is no longer applicable. Remove or update this code. crbug.com/460596
+    LayoutObject* rootForThisLayout = inSubtreeLayout ? *(m_layoutSubtreeRoots.begin()) : renderView();
     if (!rootForThisLayout) {
         // FIXME: Do we need to set m_size here?
         ASSERT_NOT_REACHED();
         return;
     }
 
     FontCachePurgePreventer fontCachePurgePreventer;
-    Layer* layer;
     {
         TemporaryChange<bool> changeSchedulingEnabled(m_layoutSchedulingEnabled, false);
 
         m_nestedLayoutCount++;
         if (!inSubtreeLayout) {
-            Document* document = m_frame->document();
+            clearLayoutSubtreeRootsAndMarkContainingBlocks();
             Node* body = document->body();
             if (body && body->renderer()) {
                 if (isHTMLFrameSetElement(*body)) {
                     body->renderer()->setChildNeedsLayout();
                 } else if (isHTMLBodyElement(*body)) {
                     if (!m_firstLayout && m_size.height() != layoutSize().height() && body->renderer()->enclosingBox()->stretchesToViewport())
                         body->renderer()->setChildNeedsLayout();
                 }
             }
         }
         updateCounters();
 
         ScrollbarMode hMode;
         ScrollbarMode vMode;
         calculateScrollbarModesForLayoutAndSetViewportRenderer(hMode, vMode);
 
         if (!inSubtreeLayout) {
             // Now set our scrollbar state for the layout.
             ScrollbarMode currentHMode = horizontalScrollbarMode();
             ScrollbarMode currentVMode = verticalScrollbarMode();
 
             if (m_firstLayout) {
                 setScrollbarsSuppressed(true);
 
                 m_doFullPaintInvalidation = true;
                 m_firstLayout = false;
                 m_firstLayoutCallbackPending = true;
                 m_lastViewportSize = layoutSize(IncludeScrollbars);
-                m_lastZoomFactor = rootForThisLayout->style()->zoom();
+                m_lastZoomFactor = renderView()->style()->zoom();
 
                 // Set the initial vMode to AlwaysOn if we're auto.
                 if (vMode == ScrollbarAuto)
                     setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.
                 // Set the initial hMode to AlwaysOff if we're auto.
                 if (hMode == ScrollbarAuto)
                     setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.
 
                 setScrollbarModes(hMode, vMode);
                 setScrollbarsSuppressed(false, true);
@@ skipping 15 matching lines @@
                     bodyRenderer->setChildNeedsLayout();
                 else if (rootRenderer && rootRenderer->stretchesToViewport())
                     rootRenderer->setChildNeedsLayout();
             }
 
             // We need to set m_doFullPaintInvalidation before triggering layout as LayoutObject::checkForPaintInvalidation
             // checks the boolean to disable local paint invalidations.
             m_doFullPaintInvalidation |= renderView()->shouldDoFullPaintInvalidationForNextLayout();
         }
 
-        layer = rootForThisLayout->enclosingLayer();
+        performLayout(inSubtreeLayout);
 
-        performLayout(rootForThisLayout, inSubtreeLayout);
-
-        m_layoutSubtreeRoot = nullptr;
-        // We need to ensure that we mark up all renderers up to the RenderView
-        // for paint invalidation. This simplifies our code as we just always
-        // do a full tree walk.
-        if (LayoutObject* container = rootForThisLayout->container())
-            container->setMayNeedPaintInvalidation();
+        m_layoutSubtreeRoots.clear();
+        m_isSubtreeLayout = false;
     } // Reset m_layoutSchedulingEnabled to its previous value.
 
-    if (!inSubtreeLayout && !toRenderView(rootForThisLayout)->document().printing())
+    if (!inSubtreeLayout && !document->printing())
         adjustViewSize();
 
-    layer->updateLayerPositionsAfterLayout();
+    // FIXME: Could find the common ancestor layer of all dirty subtrees and mark from there.
+    renderView()->enclosingLayer()->updateLayerPositionsAfterLayout();
 
     renderView()->compositor()->didLayout();
 
     m_layoutCount++;
 
-    if (AXObjectCache* cache = rootForThisLayout->document().axObjectCache()) {
-        const KURL& url = rootForThisLayout->document().url();
+    if (AXObjectCache* cache = document->axObjectCache()) {
+        const KURL& url = document->url();
         if (url.isValid() && !url.isAboutBlankURL())
-            cache->handleLayoutComplete(rootForThisLayout);
+            cache->handleLayoutComplete(document);
     }
     updateAnnotatedRegions();
 
-    ASSERT(!rootForThisLayout->needsLayout());
-
     if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
         updateOverflowStatus(layoutSize().width() < contentsWidth(), layoutSize().height() < contentsHeight());
 
     scheduleOrPerformPostLayoutTasks();
 
+    // FIXME: The notion of a single root for layout is no longer applicable. Remove or update this code. crbug.com/460596
     TRACE_EVENT_END1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Layout", "endData", InspectorLayoutEvent::endData(rootForThisLayout));
-    InspectorInstrumentation::didLayout(m_frame.get(), rootForThisLayout);
+    InspectorInstrumentation::didLayout(m_frame.get());
 
     m_nestedLayoutCount--;
     if (m_nestedLayoutCount)
         return;
 
 #if ENABLE(ASSERT)
     // Post-layout assert that nobody was re-marked as needing layout during layout.
-    document->renderView()->assertSubtreeIsLaidOut();
+    renderView()->assertSubtreeIsLaidOut();
 #endif
 
     // FIXME: It should be not possible to remove the FrameView from the frame/page during layout
     // however m_inPerformLayout is not set for most of this function, so none of our RELEASE_ASSERTS
     // in LocalFrame/Page will fire. One of the post-layout tasks is disconnecting the LocalFrame from
     // the page in fast/frames/crash-remove-iframe-during-object-beforeload-2.html
     // necessitating this check here.
     // ASSERT(frame()->page());
     if (frame().page())
         frame().page()->chrome().client().layoutUpdated(m_frame.get());
@@ skipping 32 matching lines @@
 
     if (m_frame->selection().isCaretBoundsDirty())
         m_frame->selection().invalidateCaretRect();
 }
 
 DocumentLifecycle& FrameView::lifecycle() const
 {
     return m_frame->document()->lifecycle();
 }
 
-void FrameView::gatherDebugLayoutRects(LayoutObject* layoutRoot)
-{
-    bool isTracing;
-    TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("blink.debug.layout"), &isTracing);
-    if (!isTracing)
-        return;
-    if (!layoutRoot->enclosingLayer()->hasCompositedLayerMapping())
-        return;
-    // For access to compositedLayerMapping().
-    DisableCompositingQueryAsserts disabler;
-    GraphicsLayer* graphicsLayer = layoutRoot->enclosingLayer()->compositedLayerMapping()->mainGraphicsLayer();
-    if (!graphicsLayer)
-        return;
-
-    GraphicsLayerDebugInfo& debugInfo = graphicsLayer->debugInfo();
-
-    debugInfo.currentLayoutRects().clear();
-    for (LayoutObject* renderer = layoutRoot; renderer; renderer = renderer->nextInPreOrder()) {
-        if (renderer->layoutDidGetCalledSinceLastFrame()) {
-            FloatQuad quad = renderer->localToAbsoluteQuad(FloatQuad(renderer->previousPaintInvalidationRect()));
-            LayoutRect rect = quad.enclosingBoundingBox();
-            debugInfo.currentLayoutRects().append(rect);
-        }
-    }
-}
-
 RenderBox* FrameView::embeddedContentBox() const
 {
     RenderView* renderView = this->renderView();
     if (!renderView)
         return nullptr;
 
     LayoutObject* firstChild = renderView->firstChild();
     if (!firstChild || !firstChild->isBox())
         return nullptr;
 
@@ skipping 656 matching lines @@
 
 void FrameView::handleLoadCompleted()
 {
     // Once loading has completed, allow autoSize one last opportunity to
     // reduce the size of the frame.
     if (m_autoSizeInfo)
         m_autoSizeInfo->autoSizeIfNeeded();
     maintainScrollPositionAtAnchor(0);
 }
 
+void FrameView::clearLayoutSubtreeRoot(const LayoutObject* root)
+{
+    m_layoutSubtreeRoots.remove(const_cast<LayoutObject*>(root));
+    if (m_layoutSubtreeRoots.isEmpty())
+        m_isSubtreeLayout = false;
+}
+
+void FrameView::clearLayoutSubtreeRootsAndMarkContainingBlocks()
+{
+    for (auto& iter : m_layoutSubtreeRoots)
+        iter->markContainingBlocksForLayout(false);
+    m_layoutSubtreeRoots.clear();
+}
+
 void FrameView::scheduleRelayout()
 {
     ASSERT(m_frame->view() == this);
 
-    if (isSubtreeLayout()) {
-        m_layoutSubtreeRoot->markContainingBlocksForLayout(false);
-        m_layoutSubtreeRoot = nullptr;
-    }
+    m_isSubtreeLayout = false;
     if (!m_layoutSchedulingEnabled)
         return;
     if (!needsLayout())
         return;
     if (!m_frame->document()->shouldScheduleLayout())
         return;
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "InvalidateLayout", "data", InspectorInvalidateLayoutEvent::data(m_frame.get()));
 
     if (m_hasPendingLayout)
         return;
+    clearLayoutSubtreeRootsAndMarkContainingBlocks();
     m_hasPendingLayout = true;
 
     page()->animator().scheduleVisualUpdate(m_frame.get());
     lifecycle().ensureStateAtMost(DocumentLifecycle::StyleClean);
 }
 
-static bool isObjectAncestorContainerOf(LayoutObject* ancestor, LayoutObject* descendant)
-{
-    for (LayoutObject* r = descendant; r; r = r->container()) {
-        if (r == ancestor)
-            return true;
-    }
-    return false;
-}
-
 void FrameView::scheduleRelayoutOfSubtree(LayoutObject* relayoutRoot)
 {
     ASSERT(m_frame->view() == this);
 
     // FIXME: Should this call shouldScheduleLayout instead?
     if (!m_frame->document()->isActive())
         return;
 
     RenderView* renderView = this->renderView();
     if (renderView && renderView->needsLayout()) {
+        ASSERT(!m_isSubtreeLayout);
         if (relayoutRoot)
             relayoutRoot->markContainingBlocksForLayout(false);
         return;
     }
 
-    if (layoutPending() || !m_layoutSchedulingEnabled) {
-        if (m_layoutSubtreeRoot != relayoutRoot) {
-            if (isObjectAncestorContainerOf(m_layoutSubtreeRoot, relayoutRoot)) {
-                // Keep the current root
-                relayoutRoot->markContainingBlocksForLayout(false, m_layoutSubtreeRoot);
-                ASSERT(!m_layoutSubtreeRoot->container() || !m_layoutSubtreeRoot->container()->needsLayout());
-            } else if (isSubtreeLayout() && isObjectAncestorContainerOf(relayoutRoot, m_layoutSubtreeRoot)) {
-                // Re-root at relayoutRoot
-                m_layoutSubtreeRoot->markContainingBlocksForLayout(false, relayoutRoot);
-                m_layoutSubtreeRoot = relayoutRoot;
-                ASSERT(!m_layoutSubtreeRoot->container() || !m_layoutSubtreeRoot->container()->needsLayout());
-            } else {
-                // Just do a full relayout
-                if (isSubtreeLayout())
-                    m_layoutSubtreeRoot->markContainingBlocksForLayout(false);
-                m_layoutSubtreeRoot = nullptr;
-                relayoutRoot->markContainingBlocksForLayout(false);
-            }
-        }
-    } else if (m_layoutSchedulingEnabled) {
-        m_layoutSubtreeRoot = relayoutRoot;
-        ASSERT(!m_layoutSubtreeRoot->container() || !m_layoutSubtreeRoot->container()->needsLayout());
+    if (relayoutRoot == renderView) {
+        m_isSubtreeLayout = false;
+        clearLayoutSubtreeRootsAndMarkContainingBlocks();
+    } else {
+        m_isSubtreeLayout = true;
+        m_layoutSubtreeRoots.add(relayoutRoot);
+    }
+    if (m_layoutSchedulingEnabled) {
         m_hasPendingLayout = true;
 
         page()->animator().scheduleVisualUpdate(m_frame.get());
         lifecycle().ensureStateAtMost(DocumentLifecycle::StyleClean);
     }
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "InvalidateLayout", "data", InspectorInvalidateLayoutEvent::data(m_frame.get()));
 }
 
 bool FrameView::layoutPending() const
 {
@@ skipping 2160 matching lines @@
 {
     Settings* settings = frame().settings();
     if (!settings || !settings->rootLayerScrolls())
         return this;
 
     RenderView* renderView = this->renderView();
     return renderView ? renderView->scrollableArea() : nullptr;
 }
 
 } // namespace blink