Only store previous clip rects for PaintLayers that support subsequences.

third_party/WebKit/Source/core/paint/PrePaintTreeWalk.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/PrePaintTreeWalk.h"
 
 #include "core/dom/DocumentLifecycle.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/graphics/paint/GeometryMapper.h"
 
 namespace blink {
 
 struct PrePaintTreeWalkContext {
   PrePaintTreeWalkContext()
       : tree_builder_context(
             WTF::WrapUnique(new PaintPropertyTreeBuilderContext)),
         paint_invalidator_context(tree_builder_context.get()),
         ancestor_overflow_paint_layer(nullptr),
-        ancestor_transformed_or_root_paint_layer(nullptr) {}
+        ancestor_transformed_or_root_paint_layer(nullptr),
+        enclosing_paint_layer(nullptr) {}
 
   PrePaintTreeWalkContext(const PrePaintTreeWalkContext& parent_context,
                           bool needs_tree_builder_context)
       : tree_builder_context(
             WTF::WrapUnique(needs_tree_builder_context || DCHECK_IS_ON()
                                 ? new PaintPropertyTreeBuilderContext(
                                       *parent_context.tree_builder_context)
                                 : nullptr)),
         paint_invalidator_context(tree_builder_context.get(),
                                   parent_context.paint_invalidator_context),
         ancestor_overflow_paint_layer(
             parent_context.ancestor_overflow_paint_layer),
         ancestor_transformed_or_root_paint_layer(
-            parent_context.ancestor_transformed_or_root_paint_layer) {
+            parent_context.ancestor_transformed_or_root_paint_layer),
+        enclosing_paint_layer(parent_context.enclosing_paint_layer) {
 #if DCHECK_IS_ON()
     if (needs_tree_builder_context)
       DCHECK(parent_context.tree_builder_context->is_actually_needed);
     tree_builder_context->is_actually_needed = needs_tree_builder_context;
 #endif
   }
 
   // PaintPropertyTreeBuilderContext is large and can lead to stack overflows
   // when recursion is deep so this context object is allocated on the heap.
   // See: https://crbug.com/698653.
   std::unique_ptr<PaintPropertyTreeBuilderContext> tree_builder_context;
 
   PaintInvalidatorContext paint_invalidator_context;
 
   // The ancestor in the PaintLayer tree which has overflow clip, or
   // is the root layer. Note that it is tree ancestor, not containing
   // block or stacking ancestor.
   PaintLayer* ancestor_overflow_paint_layer;
   PaintLayer* ancestor_transformed_or_root_paint_layer;
+  PaintLayer* enclosing_paint_layer;
 };
 
 void PrePaintTreeWalk::Walk(FrameView& root_frame) {
   DCHECK(root_frame.GetFrame().GetDocument()->Lifecycle().GetState() ==
          DocumentLifecycle::kInPrePaint);
 
   PrePaintTreeWalkContext initial_context;
   initial_context.ancestor_transformed_or_root_paint_layer =
       root_frame.GetLayoutView()->Layer();
 
   // GeometryMapper depends on paint properties.
-  if (NeedsTreeBuilderContextUpdate(root_frame, initial_context))
+  if (NeedsTreeBuilderContextUpdate(root_frame, initial_context)) {
     GeometryMapper::ClearCache();
+  }
 
   Walk(root_frame, initial_context);
   paint_invalidator_.ProcessPendingDelayedPaintInvalidations();
 }
 
 void PrePaintTreeWalk::Walk(FrameView& frame_view,
                             const PrePaintTreeWalkContext& parent_context) {
   if (frame_view.ShouldThrottleRendering()) {
     // Skip the throttled frame. Will update it when it becomes unthrottled.
     return;
   }
-
   bool needs_tree_builder_context_update =
       this->NeedsTreeBuilderContextUpdate(frame_view, parent_context);
   PrePaintTreeWalkContext context(parent_context,
                                   needs_tree_builder_context_update);
   // ancestorOverflowLayer does not cross frame boundaries.
   context.ancestor_overflow_paint_layer = nullptr;
   if (context.tree_builder_context) {
     property_tree_builder_.UpdateProperties(frame_view,
                                             *context.tree_builder_context);
   }
   paint_invalidator_.InvalidatePaintIfNeeded(frame_view,
                                              context.paint_invalidator_context);
 
   if (LayoutView* view = frame_view.GetLayoutView()) {
-    Walk(*view, context);
+    bool ignored;
+    if (!ShouldEarlyOut(*view, context, ignored)) {
+      context.enclosing_paint_layer = view->Layer();
+      if (!context.tree_builder_context) {
+        context.tree_builder_context =
+            WTF::WrapUnique(new PaintPropertyTreeBuilderContext);

[chrishtr, 2017/04/12 17:31:41]

This is a little weird and awkward, let's discuss offline ways to improve this
code.

+      }
+#if DCHECK_IS_ON()
+      if (context.tree_builder_context)
+        context.tree_builder_context->is_actually_needed = true;
+#endif
+      Walk(*view, context);
+    }
 #if DCHECK_IS_ON()
     view->AssertSubtreeClearedPaintInvalidationFlags();
 #endif
   }
   frame_view.ClearNeedsPaintPropertyUpdate();
 }
 
 static void UpdateAuxiliaryObjectProperties(const LayoutObject& object,
                                             PrePaintTreeWalkContext& context) {
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
@@ skipping 11 matching lines @@
 
     // Sticky position constraints and ancestor overflow scroller affect the
     // sticky layer position, so we need to update it again here.
     // TODO(flackr): This should be refactored in the future to be clearer (i.e.
     // update layer position and ancestor inputs updates in the same walk).
     paint_layer->UpdateLayerPosition();
   }
 
   if (paint_layer->IsRootLayer() || object.HasOverflowClip())
     context.ancestor_overflow_paint_layer = paint_layer;
+
+  context.enclosing_paint_layer = paint_layer;
 }
 
 void PrePaintTreeWalk::ComputeClipRectForContext(
     const PaintPropertyTreeBuilderContext::ContainingBlockContext& context,
     const EffectPaintPropertyNode* effect,
     const PropertyTreeState& ancestor_state,
     const LayoutPoint& ancestor_paint_offset,
     FloatClipRect& clip_rect) {
   PropertyTreeState local_state(context.transform, context.clip, effect);
 
   clip_rect =
       GeometryMapper::SourceToDestinationClipRect(local_state, ancestor_state);
   clip_rect.MoveBy(-FloatPoint(ancestor_paint_offset));
 }
 
 void PrePaintTreeWalk::InvalidatePaintLayerOptimizationsIfNeeded(
     const LayoutObject& object,
     PrePaintTreeWalkContext& context) {
   if (!object.HasLayer())
     return;
 
   PaintLayer& paint_layer = *ToLayoutBoxModelObject(object).Layer();
+  if (!paint_layer.SupportsSubsequenceCaching())
+    return;
+
   if (object.StyleRef().HasTransform() ||
       &object ==
           context.paint_invalidator_context.paint_invalidation_container) {
     context.ancestor_transformed_or_root_paint_layer = &paint_layer;
   }
 
   const auto& ancestor =
       context.ancestor_transformed_or_root_paint_layer->GetLayoutObject();
   PropertyTreeState ancestor_state = *ancestor.LocalBorderBoxProperties();
 
@@ skipping 78 matching lines @@
 
 bool PrePaintTreeWalk::NeedsTreeBuilderContextUpdate(
     const LayoutObject& object,
     const PrePaintTreeWalkContext& parent_context) {
   return object.NeedsPaintPropertyUpdate() ||
          object.DescendantNeedsPaintPropertyUpdate() ||
          (parent_context.tree_builder_context &&
           parent_context.tree_builder_context->force_subtree_update) ||
          // If the object needs visual rect update, we should update tree
          // builder context which is needed by visual rect update.
-         parent_context.paint_invalidator_context.NeedsVisualRectUpdate(object);
+         parent_context.paint_invalidator_context.NeedsVisualRectUpdate(
+             object) ||
+         (parent_context.enclosing_paint_layer &&

[pdr., 2017/04/12 18:40:06]

Can enclosing_paint_layer ever be null here?

Do we actually need to track the enclosing paint layer or can we just track a
bool for HasDescendantThatSupportsSubsequenceCaching?

+          parent_context.enclosing_paint_layer
+              ->HasDescendantThatSupportsSubsequenceCaching());
+}
+
+bool PrePaintTreeWalk::ShouldEarlyOut(
+    const LayoutObject& object,
+    const PrePaintTreeWalkContext& parent_context,
+    bool& needs_tree_builder_context_update) {
+  // Early out from the tree walk if possible.
+  needs_tree_builder_context_update =
+      this->NeedsTreeBuilderContextUpdate(object, parent_context);
+  return !needs_tree_builder_context_update &&
+         !object.ShouldCheckForPaintInvalidation();
 }
 
 void PrePaintTreeWalk::Walk(const LayoutObject& object,
                             const PrePaintTreeWalkContext& parent_context) {
-  // Early out from the tree walk if possible.
-  bool needs_tree_builder_context_update =
-      this->NeedsTreeBuilderContextUpdate(object, parent_context);
-  if (!needs_tree_builder_context_update &&
-      !object.ShouldCheckForPaintInvalidation())
+  bool needs_tree_builder_context_update = false;
+  if (ShouldEarlyOut(object, parent_context, needs_tree_builder_context_update))
     return;
 
   PrePaintTreeWalkContext context(parent_context,
                                   needs_tree_builder_context_update);
 
   // This must happen before updatePropertiesForSelf, because the latter reads
   // some of the state computed here.
   UpdateAuxiliaryObjectProperties(object, context);
 
   if (context.tree_builder_context) {
@@ skipping 33 matching lines @@
       }
       Walk(*ToFrameView(frame_view_base), context);
     }
     // TODO(pdr): Investigate RemoteFrameView (crbug.com/579281).
   }
 
   object.GetMutableForPainting().ClearPaintFlags();
 }
 
 }  // namespace blink