Descendants may become or cease to be spanners when an ancestor changes style.

third_party/WebKit/Source/core/layout/LayoutMultiColumnFlowThread.cpp

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 15 matching lines @@
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/MultiColumnFragmentainerGroup.h"
 #include "core/layout/ViewFragmentationContext.h"
 
 namespace blink {
 
+#if DCHECK_IS_ON()
+const LayoutBox* LayoutMultiColumnFlowThread::s_styleChangedBox;
+#endif
+bool LayoutMultiColumnFlowThread::s_couldContainSpanners;
+bool LayoutMultiColumnFlowThread::s_toggleSpannersIfNeeded;

[mstensho (USE GERRIT), 2016/11/04 20:09:42]

This is similar to the static bool s_affectsParentBlock mechanism in
LayoutObject. We need to maintain state between styleWillChange() and
styleDidChange() (and hope that the two are called in sequence on the same
layout object).

I don't think is pretty. Rather than this, should I fix LayoutObject, so that it
no longer needs s_affectsParentBlock? We could have styleWillChange() return a
context object that will be passed to the corresponding styleDidChange().

+
 LayoutMultiColumnFlowThread::LayoutMultiColumnFlowThread()
     : m_lastSetWorkedOn(nullptr),
       m_columnCount(1),
       m_columnHeightsChanged(false),
       m_progressionIsInline(true),
       m_isBeingEvacuated(false) {
   setIsInsideFlowThread(true);
 }
 
 LayoutMultiColumnFlowThread::~LayoutMultiColumnFlowThread() {}
@@ skipping 1046 matching lines @@
   // sets and spanner placeholders.
   return (!newStyle.hasOutOfFlowPosition() &&
           oldStyle.hasOutOfFlowPosition()) ||
          needsToReinsertIntoFlowThread(oldStyle, newStyle);
 }
 
 void LayoutMultiColumnFlowThread::flowThreadDescendantStyleWillChange(
     LayoutBox* descendant,
     StyleDifference diff,
     const ComputedStyle& newStyle) {
-  if (needsToRemoveFromFlowThread(descendant->styleRef(), newStyle))
+  s_toggleSpannersIfNeeded = false;
+  if (needsToRemoveFromFlowThread(descendant->styleRef(), newStyle)) {
     flowThreadDescendantWillBeRemoved(descendant);
+    return;
+  }
+#if DCHECK_IS_ON()
+  s_styleChangedBox = descendant;
+#endif
+  // Keep track of whether this object was of such a type that it could contain
+  // column-span:all descendants. If the style change in progress changes this
+  // state, we need to look for spanners to add or remove in the subtree of
+  // |descendant|.
+  s_toggleSpannersIfNeeded = true;
+  s_couldContainSpanners =
+      canContainSpannerInParentFragmentationContext(*descendant);
 }
 
 void LayoutMultiColumnFlowThread::flowThreadDescendantStyleDidChange(
     LayoutBox* descendant,
     StyleDifference diff,
     const ComputedStyle& oldStyle) {
+  bool toggleSpannersIfNeeded = s_toggleSpannersIfNeeded;
+  s_toggleSpannersIfNeeded = false;
+
   if (needsToInsertIntoFlowThread(oldStyle, descendant->styleRef())) {
     flowThreadDescendantWasInserted(descendant);
     return;
   }
   if (descendantIsValidColumnSpanner(descendant)) {
     // We went from being regular column content to becoming a spanner.
     ASSERT(!descendant->spannerPlaceholder());
 
     // First remove this as regular column content. Note that this will walk the
     // entire subtree of |descendant|. There might be spanners there (which
     // won't be spanners anymore, since we're not allowed to nest spanners),
     // whose placeholders must die.
     flowThreadDescendantWillBeRemoved(descendant);
 
     createAndInsertSpannerPlaceholder(
         descendant,
         nextInPreOrderAfterChildrenSkippingOutOfFlow(this, descendant));
+    return;
+  }
+
+  if (!toggleSpannersIfNeeded)
+    return;
+#if DCHECK_IS_ON()
+  // Make sure that we were preceded by a call to
+  // flowThreadDescendantStyleWillChange() with the same descendant as we have
+  // now.
+  DCHECK(s_styleChangedBox == descendant);
+#endif
+
+  if (s_couldContainSpanners !=
+      canContainSpannerInParentFragmentationContext(*descendant))
+    toggleSpannersInSubtree(descendant);
+}
+
+void LayoutMultiColumnFlowThread::toggleSpannersInSubtree(
+    LayoutBox* descendant) {
+  DCHECK(s_couldContainSpanners !=
+         canContainSpannerInParentFragmentationContext(*descendant));
+
+  // If there are no spanners at all in this multicol container, there's no
+  // need to look for any to remove.
+  if (s_couldContainSpanners && !hasAnyColumnSpanners(*this))
+    return;
+
+  bool walkChildren;
+  for (LayoutObject* object = descendant->nextInPreOrder(descendant); object;
+       object = walkChildren
+                    ? object->nextInPreOrder(descendant)
+                    : object->nextInPreOrderAfterChildren(descendant)) {
+    walkChildren = false;
+    if (!object->isBox())
+      continue;
+    LayoutBox& box = toLayoutBox(*object);
+    if (s_couldContainSpanners) {
+      // Remove all spanners (turn them into regular column content), as we can
+      // no longer contain them.
+      if (box.isColumnSpanAll()) {
+        destroySpannerPlaceholder(box.spannerPlaceholder());
+        continue;
+      }
+    } else if (descendantIsValidColumnSpanner(object)) {
+      // We can now contain spanners, and we found a candidate. Turn it into a
+      // spanner.
+      createAndInsertSpannerPlaceholder(
+          &box, nextInPreOrderAfterChildrenSkippingOutOfFlow(this, &box));
+      continue;
+    }
+    walkChildren = canContainSpannerInParentFragmentationContext(box);
   }
 }
 
 void LayoutMultiColumnFlowThread::computePreferredLogicalWidths() {
   LayoutFlowThread::computePreferredLogicalWidths();
 
   // The min/max intrinsic widths calculated really tell how much space elements
   // need when laid out inside the columns. In order to eventually end up with
   // the desired column width, we need to convert them to values pertaining to
   // the multicol container.
@@ skipping 114 matching lines @@
     const {
   return MultiColumnLayoutState(m_lastSetWorkedOn);
 }
 
 void LayoutMultiColumnFlowThread::restoreMultiColumnLayoutState(
     const MultiColumnLayoutState& state) {
   m_lastSetWorkedOn = state.columnSet();
 }
 
 }  // namespace blink