Introduce PaintPropertyTreeBuilderFragmentContext and use it throughout.

third_party/WebKit/Source/core/paint/FindPropertiesNeedingUpdate.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 FindPropertiesNeedingUpdate_h
 #define FindPropertiesNeedingUpdate_h
 
 #if DCHECK_IS_ON()
 
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutObject.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintPropertyTreeBuilder.h"
 
 namespace blink {
 
 // This file contains two scope classes for catching cases where paint
 // properties needed an update but were not marked as such. If paint properties
 // will change, the object must be marked as needing a paint property update
 // using {FrameView, LayoutObject}::setNeedsPaintPropertyUpdate() or by forcing
-// a subtree update (see: PaintPropertyTreeBuilderContext::forceSubtreeUpdate).
+// a subtree update (see:
+// PaintPropertyTreeBuilderContext::force_subtree_update).
 //
 // Both scope classes work by recording the paint property state of an object
 // before rebuilding properties, forcing the properties to get updated, then
 // checking that the updated properties match the original properties.
 
 #define DUMP_PROPERTIES(original, updated)                           \
   "\nOriginal:\n"                                                    \
       << (original ? (original)->ToString().Ascii().data() : "null") \
       << "\nUpdated:\n"                                              \
       << (updated ? (updated)->ToString().Ascii().data() : "null")
@@ skipping 10 matching lines @@
                                     << " needing a paint property update." \
                                     << DUMP_PROPERTIES(original, updated); \
     }                                                                      \
   } while (0)
 
 #define DCHECK_FRAMEVIEW_PROPERTY_EQ(original, updated) \
   CHECK_PROPERTY_EQ("the FrameView", original, updated)
 
 class FindFrameViewPropertiesNeedingUpdateScope {
  public:
-  FindFrameViewPropertiesNeedingUpdateScope(
-      FrameView* frame_view,
-      PaintPropertyTreeBuilderContext& context)
+  FindFrameViewPropertiesNeedingUpdateScope(FrameView* frame_view,
+                                            bool force_subtree_update)
       : frame_view_(frame_view),
         needed_paint_property_update_(frame_view->NeedsPaintPropertyUpdate()),
-        needed_forced_subtree_update_(context.force_subtree_update) {
+        needed_forced_subtree_update_(force_subtree_update) {
     // No need to check if an update was already needed.
     if (needed_paint_property_update_ || needed_forced_subtree_update_)
       return;
 
     // Mark the properties as needing an update to ensure they are rebuilt.
     frame_view_->SetOnlyThisNeedsPaintPropertyUpdateForTesting();
 
     if (auto* pre_translation = frame_view_->PreTranslation())
       original_pre_translation_ = pre_translation->Clone();
     if (auto* content_clip = frame_view_->ContentClip())
       original_content_clip_ = content_clip->Clone();
     if (auto* scroll_translation = frame_view_->ScrollTranslation())
       original_scroll_translation_ = scroll_translation->Clone();
   }
 
   ~FindFrameViewPropertiesNeedingUpdateScope() {
     // No need to check if an update was already needed.
     if (needed_paint_property_update_ || needed_forced_subtree_update_)
       return;
 
     // If these checks fail, the paint properties changed unexpectedly. This is
     // due to missing one of these paint property invalidations:
     // 1) The FrameView should have been marked as needing an update with
     //    FrameView::setNeedsPaintPropertyUpdate().
     // 2) The PrePaintTreeWalk should have had a forced subtree update (see:
-    //    PaintPropertyTreeBuilderContext::forceSubtreeUpdate).
+    //    PaintPropertyTreeBuilderContext::force_subtree_update).
     DCHECK_FRAMEVIEW_PROPERTY_EQ(original_pre_translation_,
                                  frame_view_->PreTranslation());
     DCHECK_FRAMEVIEW_PROPERTY_EQ(original_content_clip_,
                                  frame_view_->ContentClip());
     DCHECK_FRAMEVIEW_PROPERTY_EQ(original_scroll_translation_,
                                  frame_view_->ScrollTranslation());
 
     // Restore original clean bit.
     frame_view_->ClearNeedsPaintPropertyUpdate();
   }
 
  private:
   Persistent<FrameView> frame_view_;
   bool needed_paint_property_update_;
   bool needed_forced_subtree_update_;
   RefPtr<const TransformPaintPropertyNode> original_pre_translation_;
   RefPtr<const ClipPaintPropertyNode> original_content_clip_;
   RefPtr<const TransformPaintPropertyNode> original_scroll_translation_;
 };
 
 #define DCHECK_OBJECT_PROPERTY_EQ(object, original, updated)            \
   CHECK_PROPERTY_EQ("the layout object (" << object.DebugName() << ")", \
                     original, updated)
 
 class FindObjectPropertiesNeedingUpdateScope {
  public:
-  FindObjectPropertiesNeedingUpdateScope(
-      const LayoutObject& object,
-      PaintPropertyTreeBuilderContext& context)
+  FindObjectPropertiesNeedingUpdateScope(const LayoutObject& object,
+                                         bool force_subtree_update)
       : object_(object),
         needed_paint_property_update_(object.NeedsPaintPropertyUpdate()),
-        needed_forced_subtree_update_(context.force_subtree_update),
+        needed_forced_subtree_update_(force_subtree_update),
         original_paint_offset_(object.PaintOffset()) {
     // No need to check if an update was already needed.
     if (needed_paint_property_update_ || needed_forced_subtree_update_)
       return;
 
     // Mark the properties as needing an update to ensure they are rebuilt.
     object_.GetMutableForPainting()
         .SetOnlyThisNeedsPaintPropertyUpdateForTesting();
 
     if (const auto* properties = object_.PaintProperties())
@@ skipping 20 matching lines @@
 
     // No need to check if an update was already needed.
     if (needed_paint_property_update_ || needed_forced_subtree_update_)
       return;
 
     // If these checks fail, the paint properties changed unexpectedly. This is
     // due to missing one of these paint property invalidations:
     // 1) The LayoutObject should have been marked as needing an update with
     //    LayoutObject::setNeedsPaintPropertyUpdate().
     // 2) The PrePaintTreeWalk should have had a forced subtree update (see:
-    //    PaintPropertyTreeBuilderContext::forceSubtreeUpdate).
+    //    PaintPropertyTreeBuilderContext::force_subtree_update).
     if (original_properties_ && object_properties) {
       DCHECK_OBJECT_PROPERTY_EQ(object_, original_properties_->Transform(),
                                 object_properties->Transform());
       DCHECK_OBJECT_PROPERTY_EQ(object_, original_properties_->Effect(),
                                 object_properties->Effect());
       DCHECK_OBJECT_PROPERTY_EQ(object_, original_properties_->Filter(),
                                 object_properties->Filter());
       DCHECK_OBJECT_PROPERTY_EQ(object_, original_properties_->Mask(),
                                 object_properties->Mask());
       DCHECK_OBJECT_PROPERTY_EQ(object_, original_properties_->MaskClip(),
@@ skipping 51 matching lines @@
   LayoutPoint original_paint_offset_;
   std::unique_ptr<const ObjectPaintProperties> original_properties_;
   std::unique_ptr<const PropertyTreeState>
       original_local_border_box_properties_;
 };
 
 }  // namespace blink
 #endif  // DCHECK_IS_ON()
 
 #endif  // FindPropertiesNeedingUpdate_h