[SPv2] Refactor PaintInvalidator to be multicol-ready.

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

 // 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.
 
 #ifndef PaintInvalidator_h
 #define PaintInvalidator_h
 
 #include "core/layout/LayoutObject.h"
 #include "core/paint/PaintPropertyTreeBuilder.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/wtf/Vector.h"
 
 namespace blink {
 
 struct PaintInvalidatorContext {
-  PaintInvalidatorContext(
-      const PaintPropertyTreeBuilderContext* tree_builder_context)
-      : parent_context(nullptr), tree_builder_context_(tree_builder_context) {}
+  PaintInvalidatorContext() : parent_context(nullptr) {}
 
-  PaintInvalidatorContext(
-      const PaintPropertyTreeBuilderContext* tree_builder_context,
-      const PaintInvalidatorContext& parent_context)
+  PaintInvalidatorContext(const PaintInvalidatorContext& parent_context)
       : parent_context(&parent_context),
         forced_subtree_invalidation_flags(
             parent_context.forced_subtree_invalidation_flags),
         paint_invalidation_container(
             parent_context.paint_invalidation_container),
         paint_invalidation_container_for_stacked_contents(
             parent_context.paint_invalidation_container_for_stacked_contents),
-        painting_layer(parent_context.painting_layer),
-        tree_builder_context_(tree_builder_context) {}
+        painting_layer(parent_context.painting_layer) {}
 
   // This method is virtual temporarily to adapt PaintInvalidatorContext and the
   // legacy PaintInvalidationState for code shared by old code and new code.
   virtual void MapLocalRectToVisualRectInBacking(const LayoutObject&,
                                                  LayoutRect&) const;
 
   bool NeedsVisualRectUpdate(const LayoutObject& object) const {
     if (!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
       return true;
 #if DCHECK_IS_ON()
@@ skipping 57 matching lines @@
   // Store the origin of the object's local coordinates in the paint
   // invalidation backing's coordinates. They are used to detect layoutObject
   // shifts that force a full invalidation and invalidation check in subtree.
   // The points do *not* account for composited scrolling. See
   // LayoutObject::adjustVisualRectForCompositedScrolling().
   LayoutPoint old_location;
   LayoutPoint new_location;
 
  private:
   friend class PaintInvalidator;
-  const PaintPropertyTreeBuilderContext* tree_builder_context_;
+  const PaintPropertyTreeBuilderFragmentContext* tree_builder_context_ =
+      nullptr;
 
 #if DCHECK_IS_ON()
+  bool tree_builder_context_actually_needed_ = false;
+  friend class FindVisualRectNeedingUpdateScope;
   friend class FindVisualRectNeedingUpdateScopeBase;
   mutable bool force_visual_rect_update_for_checking_ = false;
 #endif
 };
 
 class PaintInvalidator {
  public:
-  void InvalidatePaint(FrameView&, PaintInvalidatorContext&);
-  void InvalidatePaint(const LayoutObject&, PaintInvalidatorContext&);
+  void InvalidatePaint(FrameView&,
+                       const PaintPropertyTreeBuilderContext*,
+                       PaintInvalidatorContext&);
+  void InvalidatePaint(const LayoutObject&,
+                       const PaintPropertyTreeBuilderContext*,
+                       PaintInvalidatorContext&);
 
   // Process objects needing paint invalidation on the next frame.
   // See the definition of PaintInvalidationDelayedFull for more details.
   void ProcessPendingDelayedPaintInvalidations();
 
  private:
   friend struct PaintInvalidatorContext;
   template <typename Rect, typename Point>
   static LayoutRect MapLocalRectToVisualRectInBacking(
       const LayoutObject&,
       const Rect&,
       const PaintInvalidatorContext&);
 
   ALWAYS_INLINE LayoutRect
   ComputeVisualRectInBacking(const LayoutObject&,
                              const PaintInvalidatorContext&);
   ALWAYS_INLINE LayoutPoint
   ComputeLocationInBacking(const LayoutObject&, const PaintInvalidatorContext&);
   ALWAYS_INLINE void UpdatePaintingLayer(const LayoutObject&,
                                          PaintInvalidatorContext&);
   ALWAYS_INLINE void UpdatePaintInvalidationContainer(const LayoutObject&,
                                                       PaintInvalidatorContext&);
-  ALWAYS_INLINE void UpdateVisualRectIfNeeded(const LayoutObject&,
-                                              PaintInvalidatorContext&);
+  ALWAYS_INLINE void UpdateVisualRectIfNeeded(
+      const LayoutObject&,
+      const PaintPropertyTreeBuilderContext*,
+      PaintInvalidatorContext&);
   ALWAYS_INLINE void UpdateVisualRect(const LayoutObject&,
                                       PaintInvalidatorContext&);
 
   Vector<const LayoutObject*> pending_delayed_paint_invalidations_;
 };
 
 }  // namespace blink
 
 #endif  // PaintInvalidator_h