Introduce PaintPropertyTreeBuilderFragmentContext and use it throughout.

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_->current.transform ==
+    if (context.tree_builder_context_->fragments[0].current.transform ==

[chrishtr, 2017/04/27 22:25:41]

The next patch will update PaintInvalidator also.

             container_contents_properties.Transform() &&
-        context.tree_builder_context_->current.clip ==
+        context.tree_builder_context_->fragments[0].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_->current.transform !=
-                               container_contents_properties.Transform())
+      if (!is_svg_child &&
+          context.tree_builder_context_->fragments[0].current.transform !=
+              container_contents_properties.Transform())
         rect = Rect(EnclosingIntRect(rect));
 
       PropertyTreeState current_tree_state(
-          context.tree_builder_context_->current.transform,
-          context.tree_builder_context_->current.clip, nullptr);
+          context.tree_builder_context_->fragments[0].current.transform,
+          context.tree_builder_context_->fragments[0].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_->current.transform !=
+    if (context.tree_builder_context_->fragments[0].current.transform !=
         container_transform) {
       FloatRect rect = FloatRect(FloatPoint(point), FloatSize());
       GeometryMapper::SourceToDestinationRect(
-          context.tree_builder_context_->current.transform, container_transform,
-          rect);
+          context.tree_builder_context_->fragments[0].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 58 matching lines @@
 // 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)
       : tree_builder_context_(
             const_cast<PaintPropertyTreeBuilderContext&>(tree_builder_context)),
-        saved_context_(tree_builder_context_.current) {
+        saved_context_(tree_builder_context_.fragments[0].current) {
     DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
 
-    if (frame_view.ContentClip() == saved_context_.clip)
-      tree_builder_context_.current.clip = saved_context_.clip->Parent();
+    if (frame_view.ContentClip() == saved_context_.clip) {
+      tree_builder_context_.fragments[0].current.clip =
+          saved_context_.clip->Parent();
+    }
     if (const auto* scroll_translation = frame_view.ScrollTranslation()) {
-      if (scroll_translation->ScrollNode() == saved_context_.scroll)
-        tree_builder_context_.current.scroll = saved_context_.scroll->Parent();
+      if (scroll_translation->ScrollNode() == saved_context_.scroll) {
+        tree_builder_context_.fragments[0].current.scroll =
+            saved_context_.scroll->Parent();
+      }
       if (scroll_translation == saved_context_.transform) {
-        tree_builder_context_.current.transform =
+        tree_builder_context_.fragments[0].current.transform =
             saved_context_.transform->Parent();
       }
     }
   }
 
   ~ScopedUndoFrameViewContentClipAndScroll() {
-    tree_builder_context_.current = saved_context_;
+    tree_builder_context_.fragments[0].current = saved_context_;
   }
 
  private:
   PaintPropertyTreeBuilderContext& tree_builder_context_;
-  PaintPropertyTreeBuilderContext::ContainingBlockContext saved_context_;
+  PaintPropertyTreeBuilderFragmentContext::ContainingBlockContext
+      saved_context_;
 };
 
 }  // namespace
 
 void PaintInvalidator::UpdatePaintInvalidationContainer(
     const LayoutObject& object,
     PaintInvalidatorContext& context) {
   if (object.IsPaintInvalidationContainer()) {
     context.paint_invalidation_container = ToLayoutBoxModelObject(&object);
     if (object.StyleRef().IsStackingContext())
@@ skipping 70 matching lines @@
   }
 
   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_->current.paint_offset ==
+  DCHECK(context.tree_builder_context_->fragments[0].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_);
   }
@@ skipping 114 matching lines @@
 }
 
 void PaintInvalidator::ProcessPendingDelayedPaintInvalidations() {
   for (auto target : pending_delayed_paint_invalidations_) {
     target->GetMutableForPainting().SetShouldDoFullPaintInvalidation(
         kPaintInvalidationDelayedFull);
   }
 }
 
 }  // namespace blink