[SPv2] Refactor PaintInvalidator to be multicol-ready.

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

 // Copyright 2016 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/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 89 matching lines @@
   } else if (object == context.paint_invalidation_container) {
     result = LayoutRect(rect);
   } else {
     // For non-root SVG, the input rect is in local SVG coordinates in which
     // paint offset doesn't apply.
     if (!is_svg_child)
       rect.MoveBy(Point(object.PaintOffset()));
 
     auto container_contents_properties =
         context.paint_invalidation_container->ContentsProperties();
-    if (context.tree_builder_context_->fragments[0].current.transform ==
+    if (context.tree_builder_context_->current.transform ==
             container_contents_properties.Transform() &&
-        context.tree_builder_context_->fragments[0].current.clip ==
+        context.tree_builder_context_->current.clip ==
             container_contents_properties.Clip()) {
       result = LayoutRect(rect);
     } else {
       // Use enclosingIntRect to ensure the final visual rect will cover the
       // rect in source coordinates no matter if the painting will use pixel
       // snapping, when transforms are applied. If there is no transform,
       // enclosingIntRect is applied in the last step of paint invalidation
       // (see CompositedLayerMapping::setContentsNeedDisplayInRect()).
-      if (!is_svg_child &&
-          context.tree_builder_context_->fragments[0].current.transform !=
-              container_contents_properties.Transform())
+      if (!is_svg_child && context.tree_builder_context_->current.transform !=
+                               container_contents_properties.Transform())
         rect = Rect(EnclosingIntRect(rect));
 
       PropertyTreeState current_tree_state(
-          context.tree_builder_context_->fragments[0].current.transform,
-          context.tree_builder_context_->fragments[0].current.clip, nullptr);
+          context.tree_builder_context_->current.transform,
+          context.tree_builder_context_->current.clip, nullptr);
 
       FloatClipRect float_rect((FloatRect(rect)));
       GeometryMapper::SourceToDestinationVisualRect(
           current_tree_state, container_contents_properties, float_rect);
       result = LayoutRect(float_rect.Rect());
     }
 
     // Convert the result to the container's contents space.
     result.MoveBy(-context.paint_invalidation_container->PaintOffset());
   }
@@ skipping 36 matching lines @@
   // In SPv2, locationInBacking is in the space of their local transform node.
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return object.PaintOffset();
 
   LayoutPoint point;
   if (object != context.paint_invalidation_container) {
     point.MoveBy(object.PaintOffset());
 
     const auto* container_transform =
         context.paint_invalidation_container->ContentsProperties().Transform();
-    if (context.tree_builder_context_->fragments[0].current.transform !=
+    if (context.tree_builder_context_->current.transform !=
         container_transform) {
       FloatRect rect = FloatRect(FloatPoint(point), FloatSize());
       GeometryMapper::SourceToDestinationRect(
-          context.tree_builder_context_->fragments[0].current.transform,
-          container_transform, rect);
+          context.tree_builder_context_->current.transform, container_transform,
+          rect);
       point = LayoutPoint(rect.Location());
     }
 
     // Convert the result to the container's contents space.
     point.MoveBy(-context.paint_invalidation_container->PaintOffset());
   }
 
   if (context.paint_invalidation_container->Layer()->GroupedMapping()) {
     FloatPoint float_point(point);
     PaintLayer::MapPointInPaintInvalidationContainerToBacking(
@@ skipping 55 matching lines @@
 
 // This is temporary to workaround paint invalidation issues in
 // non-rootLayerScrolls mode.
 // It undoes FrameView's content clip and scroll for paint invalidation of frame
 // scroll controls and the LayoutView to which the content clip and scroll don't
 // apply.
 class ScopedUndoFrameViewContentClipAndScroll {
  public:
   ScopedUndoFrameViewContentClipAndScroll(
       const FrameView& frame_view,
-      const PaintPropertyTreeBuilderContext& tree_builder_context)
+      const PaintPropertyTreeBuilderFragmentContext& tree_builder_context)
       : tree_builder_context_(
-            const_cast<PaintPropertyTreeBuilderContext&>(tree_builder_context)),
-        saved_context_(tree_builder_context_.fragments[0].current) {
+            const_cast<PaintPropertyTreeBuilderFragmentContext&>(
+                tree_builder_context)),
+        saved_context_(tree_builder_context_.current) {
     DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
 
     if (frame_view.ContentClip() == saved_context_.clip) {
-      tree_builder_context_.fragments[0].current.clip =
-          saved_context_.clip->Parent();
+      tree_builder_context_.current.clip = saved_context_.clip->Parent();
     }
     if (const auto* scroll_translation = frame_view.ScrollTranslation()) {
       if (scroll_translation->ScrollNode() == saved_context_.scroll) {
-        tree_builder_context_.fragments[0].current.scroll =
-            saved_context_.scroll->Parent();
+        tree_builder_context_.current.scroll = saved_context_.scroll->Parent();
       }
       if (scroll_translation == saved_context_.transform) {
-        tree_builder_context_.fragments[0].current.transform =
+        tree_builder_context_.current.transform =
             saved_context_.transform->Parent();
       }
     }
   }
 
   ~ScopedUndoFrameViewContentClipAndScroll() {
-    tree_builder_context_.fragments[0].current = saved_context_;
+    tree_builder_context_.current = saved_context_;
   }
 
  private:
-  PaintPropertyTreeBuilderContext& tree_builder_context_;
+  PaintPropertyTreeBuilderFragmentContext& tree_builder_context_;
   PaintPropertyTreeBuilderFragmentContext::ContainingBlockContext
       saved_context_;
 };
 
 }  // namespace
 
 void PaintInvalidator::UpdatePaintInvalidationContainer(
     const LayoutObject& object,
     PaintInvalidatorContext& context) {
   if (object.IsPaintInvalidationContainer()) {
@@ skipping 51 matching lines @@
     }
   }
 
   DCHECK(context.paint_invalidation_container ==
          object.ContainerForPaintInvalidation());
   DCHECK(context.painting_layer == object.PaintingLayer());
 }
 
 void PaintInvalidator::UpdateVisualRectIfNeeded(
     const LayoutObject& object,
+    const PaintPropertyTreeBuilderContext* tree_builder_context,
     PaintInvalidatorContext& context) {
   context.old_visual_rect = object.VisualRect();
   context.old_location = ObjectPaintInvalidator(object).LocationInBacking();
 
 #if DCHECK_IS_ON()
-  FindObjectVisualRectNeedingUpdateScope finder(object, context);
+  FindObjectVisualRectNeedingUpdateScope finder(
+      object, context,
+      tree_builder_context && tree_builder_context->is_actually_needed);
+
+  context.tree_builder_context_actually_needed_ =
+      tree_builder_context->is_actually_needed;
 #endif
 
   if (!context.NeedsVisualRectUpdate(object)) {
     context.new_location = context.old_location;
     return;
   }
 
-  UpdateVisualRect(object, context);
+  DCHECK(tree_builder_context);
+  for (auto& fragment : tree_builder_context->fragments) {
+    context.tree_builder_context_ = &fragment;
+    UpdateVisualRect(object, context);
+  }
 }
 
 void PaintInvalidator::UpdateVisualRect(const LayoutObject& object,
                                         PaintInvalidatorContext& context) {
   // The paint offset should already be updated through
   // PaintPropertyTreeBuilder::updatePropertiesForSelf.
-  DCHECK(context.tree_builder_context_);
-  DCHECK(context.tree_builder_context_->fragments[0].current.paint_offset ==
+  DCHECK(context.tree_builder_context_->current.paint_offset ==
          object.PaintOffset());
 
   Optional<ScopedUndoFrameViewContentClipAndScroll>
       undo_frame_view_content_clip_and_scroll;
 
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       object.IsLayoutView() && !object.IsPaintInvalidationContainer()) {
     undo_frame_view_content_clip_and_scroll.emplace(
         *ToLayoutView(object).GetFrameView(), *context.tree_builder_context_);
   }
 
   LayoutRect new_visual_rect = ComputeVisualRectInBacking(object, context);
   if (object.IsBoxModelObject()) {
     context.new_location = ComputeLocationInBacking(object, context);
     // Location of empty visual rect doesn't affect paint invalidation. Set it
     // to newLocation to avoid saving the previous location separately in
     // ObjectPaintInvalidator.
     if (new_visual_rect.IsEmpty())
       new_visual_rect.SetLocation(context.new_location);
   } else {
     // Use visual rect location for non-LayoutBoxModelObject because it suffices
     // to check whether a visual rect changes for layout caused invalidation.
     context.new_location = new_visual_rect.Location();
   }
 
   object.GetMutableForPainting().SetVisualRect(new_visual_rect);
   ObjectPaintInvalidator(object).SetLocationInBacking(context.new_location);
 }
 
-void PaintInvalidator::InvalidatePaint(FrameView& frame_view,
-                                       PaintInvalidatorContext& context) {
+void PaintInvalidator::InvalidatePaint(
+    FrameView& frame_view,
+    const PaintPropertyTreeBuilderContext* tree_builder_context,
+
+    PaintInvalidatorContext& context) {
   LayoutView* layout_view = frame_view.GetLayoutView();
   CHECK(layout_view);
 
   context.paint_invalidation_container =
       context.paint_invalidation_container_for_stacked_contents =
           &layout_view->ContainerForPaintInvalidation();
   context.painting_layer = layout_view->Layer();
+  if (tree_builder_context) {
+    context.tree_builder_context_ = &tree_builder_context->fragments[0];
+#if DCHECK_IS_ON()
+    context.tree_builder_context_actually_needed_ =
+        tree_builder_context->is_actually_needed;
+#endif
+  }
 
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     Optional<ScopedUndoFrameViewContentClipAndScroll> undo;
-    if (context.tree_builder_context_)
+    if (tree_builder_context)
       undo.emplace(frame_view, *context.tree_builder_context_);
     frame_view.InvalidatePaintOfScrollControlsIfNeeded(context);
   }
 }
 
-void PaintInvalidator::InvalidatePaint(const LayoutObject& object,
-                                       PaintInvalidatorContext& context) {
+void PaintInvalidator::InvalidatePaint(
+    const LayoutObject& object,
+    const PaintPropertyTreeBuilderContext* tree_builder_context,
+    PaintInvalidatorContext& context) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"),
                "PaintInvalidator::invalidatePaintIfNeeded()", "object",
                object.DebugName().Ascii());
 
   object.GetMutableForPainting().EnsureIsReadyForPaintInvalidation();
 
   UpdatePaintingLayer(object, context);
 
   if (object.GetDocument().Printing() &&
       !RuntimeEnabledFeatures::printBrowserEnabled())
     return;  // Don't invalidate paints if we're printing.
 
   // TODO(crbug.com/637313): Use GeometryMapper which now supports filter
   // geometry effects, after skia optimizes filter's mapRect operation.
   // TODO(crbug.com/648274): This is a workaround for multi-column contents.
   if (object.HasFilterInducingProperty() || object.IsLayoutFlowThread()) {
     context.forced_subtree_invalidation_flags |=
         PaintInvalidatorContext::kForcedSubtreeSlowPathRect;
   }
 
   UpdatePaintInvalidationContainer(object, context);
-  UpdateVisualRectIfNeeded(object, context);
+  UpdateVisualRectIfNeeded(object, tree_builder_context, context);
 
   if (!object.ShouldCheckForPaintInvalidation() &&
       !(context.forced_subtree_invalidation_flags &
         ~PaintInvalidatorContext::kForcedSubtreeVisualRectUpdate)) {
     // We are done updating anything needed. No other paint invalidation work to
     // do for this object.
     return;
   }
 
   if (object.IsSVGHiddenContainer()) {
@@ skipping 42 matching lines @@
 
 void PaintInvalidator::ProcessPendingDelayedPaintInvalidations() {
   for (auto target : pending_delayed_paint_invalidations_) {
     target->GetMutableForPainting()
         .SetShouldDoFullPaintInvalidationWithoutGeometryChange(
             kPaintInvalidationDelayedFull);
   }
 }
 
 }  // namespace blink