Remove multicol special-cases from invalidation and the pre-paint tree walk

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilder.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/PaintPropertyTreeBuilder.h"
 
 #include "core/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 842 matching lines @@
       return;
     }
   }
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     if (auto* properties = object.getMutableForPainting().paintProperties())
       context.forceSubtreeUpdate |= properties->clearCssClipFixedPosition();
   }
 }
 
-// Override ContainingBlockContext based on the properties of a containing block
-// that was previously walked in a subtree other than the current subtree being
-// walked. Used for out-of-flow positioned descendants of multi-column spanner
-// when the containing block is not in the normal tree walk order.
-// For example:
-// <div id="columns" style="columns: 2">
-//   <div id="relative" style="position: relative">
-//     <div id="spanner" style="column-span: all">
-//       <div id="absolute" style="position: absolute"></div>
-//     </div>
-//   </div>
-// <div>
-// The real containing block of "absolute" is "relative" which is not in the
-// tree-walk order of "columns" -> spanner placeholder -> spanner -> absolute.
-// Here we rebuild a ContainingBlockContext based on the properties of
-// "relative" for "absolute".
-static void overrideContainingBlockContextFromRealContainingBlock(
-    const LayoutBlock& containingBlock,
-    PaintPropertyTreeBuilderContext::ContainingBlockContext& context) {
-  const auto* properties =
-      containingBlock.paintProperties()->localBorderBoxProperties();
-  DCHECK(properties);
-
-  context.transform = properties->transform();
-  context.paintOffset = containingBlock.paintOffset();
-  context.shouldFlattenInheritedTransform =
-      context.transform && context.transform->flattensInheritedTransform();
-  context.renderingContextId =
-      context.transform ? context.transform->renderingContextId() : 0;
-  context.clip = properties->clip();
-  context.scroll = properties->scroll();
-}
-
 void PaintPropertyTreeBuilder::updateContextForBoxPosition(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isBoxModelObject())
     return;
 
   const LayoutBoxModelObject& boxModelObject = toLayoutBoxModelObject(object);
 
   if (boxModelObject.isFloating())
     context.current.paintOffset = context.paintOffsetForFloat;
 
+  // Multicolumn spanners are painted starting at the multicolumn container (but
+  // still inherit properties in layout-tree order) so reset the paint offset.
+  if (boxModelObject.isColumnSpanAll())
+    context.current.paintOffset = boxModelObject.container()->paintOffset();
+
   switch (object.styleRef().position()) {
     case StaticPosition:
       break;
     case RelativePosition:
       context.current.paintOffset += boxModelObject.offsetForInFlowPosition();
       break;
     case AbsolutePosition: {
-      if (context.isUnderMultiColumnSpanner) {
-        const LayoutObject* container = boxModelObject.container();
-        if (container != context.containerForAbsolutePosition) {
-          // The container of the absolute-position is not in the normal tree-
-          // walk order.
-          context.containerForAbsolutePosition =
-              toLayoutBoxModelObject(container);
-          // The container is never a LayoutInline. In the example above
-          // overrideContainingBlockContextFromRealContainingBlock(), if we
-          // change the container to an inline, there will be an anonymous
-          // blocks created because the spanner is always a block.
-          overrideContainingBlockContextFromRealContainingBlock(
-              toLayoutBlock(*container), context.current);
-        }
-      } else {
-        DCHECK(context.containerForAbsolutePosition ==
-               boxModelObject.container());
-        context.current = context.absolutePosition;
-      }
+      DCHECK(context.containerForAbsolutePosition ==
+             boxModelObject.container());
+      context.current = context.absolutePosition;
 
       // Absolutely positioned content in an inline should be positioned
       // relative to the inline.
       const LayoutObject* container = context.containerForAbsolutePosition;
       if (container && container->isInFlowPositioned() &&
           container->isLayoutInline()) {
         DCHECK(object.isBox());
         context.current.paintOffset +=
             toLayoutInline(container)->offsetForInFlowPositionedInline(
                 toLayoutBox(object));
       }
       break;
     }
     case StickyPosition:
       context.current.paintOffset += boxModelObject.offsetForInFlowPosition();
       break;
     case FixedPosition:
-      if (context.isUnderMultiColumnSpanner) {
-        // The container of the fixed-position object may or may not be in the
-        // normal tree-walk order.
-        overrideContainingBlockContextFromRealContainingBlock(
-            toLayoutBlock(*boxModelObject.container()), context.current);
-      } else {
-        context.current = context.fixedPosition;
-      }
+      context.current = context.fixedPosition;
       break;
     default:
       ASSERT_NOT_REACHED();
   }
 
   if (boxModelObject.isBox()) {
     // TODO(pdr): Several calls in this function walk back up the tree to
     // calculate containers (e.g., physicalLocation, offsetForInFlowPosition*).
     // The containing block and other containers can be stored on
     // PaintPropertyTreeBuilderContext instead of recomputing them.
@@ skipping 49 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink