Merge list of orthogonal writing mode roots into depth-ordered layout list.

third_party/WebKit/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 1033 matching lines @@
   ASSERT(inSubtreeLayout || m_layoutSubtreeRootList.isEmpty());
 
   int contentsHeightBeforeLayout = layoutViewItem().documentRect().height();
   TRACE_EVENT_BEGIN1(PERFORM_LAYOUT_TRACE_CATEGORIES,
                      "FrameView::performLayout", "contentsHeightBeforeLayout",
                      contentsHeightBeforeLayout);
   prepareLayoutAnalyzer();
 
   ScriptForbiddenScope forbidScript;
 
+  if (inSubtreeLayout && hasOrthogonalWritingModeRoots()) {
+    // If we're going to lay out from each subtree root, rather than once from
+    // LayoutView, we need to merge the depth-ordered orthogonal writing mode
+    // root list into the depth-ordered list of subtrees scheduled for
+    // layout. Otherwise, during layout of one such subtree, we'd risk skipping
+    // over a subtree of objects needing layout.
+    DCHECK(!m_layoutSubtreeRootList.isEmpty());
+    scheduleOrthogonalWritingModeRootsForLayout();
+  }
+
   ASSERT(!isInPerformLayout());
   lifecycle().advanceTo(DocumentLifecycle::InPerformLayout);
 
   // 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.
 
   forceLayoutParentViewIfNeeded();
 
-  if (hasOrthogonalWritingModeRoots())
-    layoutOrthogonalWritingModeRoots();
-
   if (inSubtreeLayout) {
     if (m_analyzer)
       m_analyzer->increment(LayoutAnalyzer::PerformLayoutRootLayoutObjects,
                             m_layoutSubtreeRootList.size());
     for (auto& root : m_layoutSubtreeRootList.ordered()) {
       if (!root->needsLayout())
         continue;
       layoutFromRootObject(*root);
 
       // We need to ensure that we mark up all layoutObjects up to the
       // LayoutView for paint invalidation. This simplifies our code as we just
       // always do a full tree walk.
       if (LayoutItem container = LayoutItem(root->container()))
         container.setMayNeedPaintInvalidation();
     }
     m_layoutSubtreeRootList.clear();
   } else {
+    if (hasOrthogonalWritingModeRoots())
+      layoutOrthogonalWritingModeRoots();
     layoutFromRootObject(*layoutView());
   }
 
   m_frame->document()->fetcher()->updateAllImageResourcePriorities();
 
   lifecycle().advanceTo(DocumentLifecycle::AfterPerformLayout);
 
   TRACE_EVENT_END1(PERFORM_LAYOUT_TRACE_CATEGORIES, "FrameView::performLayout",
                    "counters", analyzerCounters());
   FirstMeaningfulPaintDetector::from(*m_frame->document())
@@ skipping 1033 matching lines @@
   // since the containing block of orthogonal writing mode roots
   // having floats is very rare, prefer to re-create
   // FloatingObjects.
   if (LayoutBlock* cb = root.containingBlock()) {
     if ((cb->normalChildNeedsLayout() || cb->selfNeedsLayout()) &&
         cb->isLayoutBlockFlow())
       toLayoutBlockFlow(cb)->removeFloatingObjects();
   }
 }
 
+static bool prepareOrthogonalWritingModeRootForLayout(LayoutObject& root) {
+  DCHECK(root.isBox() && toLayoutBox(root).isOrthogonalWritingModeRoot());
+  if (!root.needsLayout() || root.isOutOfFlowPositioned() ||
+      root.isColumnSpanAll() ||
+      !root.styleRef().logicalHeight().isIntrinsicOrAuto())
+    return false;
+
+  removeFloatingObjectsForSubtreeRoot(root);
+  return true;
+}
+
 void FrameView::layoutOrthogonalWritingModeRoots() {
   for (auto& root : m_orthogonalWritingModeRootList.ordered()) {
-    ASSERT(root->isBox() && toLayoutBox(*root).isOrthogonalWritingModeRoot());
-    if (!root->needsLayout() || root->isOutOfFlowPositioned() ||
-        root->isColumnSpanAll() ||
-        !root->styleRef().logicalHeight().isIntrinsicOrAuto()) {
-      continue;
-    }
-
-    removeFloatingObjectsForSubtreeRoot(*root);
-    layoutFromRootObject(*root);
+    if (prepareOrthogonalWritingModeRootForLayout(*root))
+      layoutFromRootObject(*root);
   }
 }
 
+void FrameView::scheduleOrthogonalWritingModeRootsForLayout() {
+  for (auto& root : m_orthogonalWritingModeRootList.ordered()) {
+    if (prepareOrthogonalWritingModeRootForLayout(*root))
+      m_layoutSubtreeRootList.add(*root);
+  }
+}
+
 bool FrameView::checkLayoutInvalidationIsAllowed() const {
   if (m_allowsLayoutInvalidationAfterLayoutClean)
     return true;
 
   // If we are updating all lifecycle phases beyond LayoutClean, we don't expect
   // dirty layout after LayoutClean.
   CHECK_FOR_DIRTY_LAYOUT(lifecycle().state() < DocumentLifecycle::LayoutClean);
 
   return true;
 }
@@ skipping 2870 matching lines @@
     std::unique_ptr<CompositorAnimationTimeline> timeline) {
   m_animationTimeline = std::move(timeline);
 }
 
 void FrameView::setAnimationHost(
     std::unique_ptr<CompositorAnimationHost> host) {
   m_animationHost = std::move(host);
 }
 
 }  // namespace blink