Only store previous clip rects for PaintLayers that support subsequences.

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 139 matching lines @@
       previous_paint_result_(kFullyPainted),
       needs_paint_phase_descendant_outlines_(false),
       previous_paint_phase_descendant_outlines_was_empty_(false),
       needs_paint_phase_float_(false),
       previous_paint_phase_float_was_empty_(false),
       needs_paint_phase_descendant_block_backgrounds_(false),
       previous_paint_phase_descendant_block_backgrounds_was_empty_(false),
       has_descendant_with_clip_path_(false),
       has_non_isolated_descendant_with_blend_mode_(false),
       has_ancestor_with_clip_path_(false),
+      has_descendant_that_supports_subsequence_caching_(false),
       self_painting_status_changed_(false),
       layout_object_(layout_object),
       parent_(0),
       previous_(0),
       next_(0),
       first_(0),
       last_(0),
       static_inline_position_(0),
       static_block_position_(0),
       ancestor_overflow_layer_(nullptr) {
@@ skipping 509 matching lines @@
   }
 }
 
 void PaintLayer::UpdateDescendantDependentFlags() {
   if (needs_descendant_dependent_flags_update_) {
     bool old_has_non_isolated_descendant_with_blend_mode =
         has_non_isolated_descendant_with_blend_mode_;
     has_visible_descendant_ = false;
     has_non_isolated_descendant_with_blend_mode_ = false;
     has_descendant_with_clip_path_ = false;
+    has_descendant_that_supports_subsequence_caching_ = false;
 
     for (PaintLayer* child = FirstChild(); child;
          child = child->NextSibling()) {
       child->UpdateDescendantDependentFlags();
 
       if (child->has_visible_content_ || child->has_visible_descendant_)
         has_visible_descendant_ = true;
 
       has_non_isolated_descendant_with_blend_mode_ |=
           (!child->StackingNode()->IsStackingContext() &&
            child->HasNonIsolatedDescendantWithBlendMode()) ||
           child->GetLayoutObject().StyleRef().HasBlendMode();
 
       has_descendant_with_clip_path_ |= child->HasDescendantWithClipPath() ||
                                         child->GetLayoutObject().HasClipPath();
+
+      has_descendant_that_supports_subsequence_caching_ |=
+          child->HasDescendantThatSupportsSubsequenceCaching() ||
+          child->SupportsSubsequenceCaching();
     }
 
     if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
         old_has_non_isolated_descendant_with_blend_mode !=
             static_cast<bool>(has_non_isolated_descendant_with_blend_mode_))
       GetLayoutObject().SetNeedsPaintPropertyUpdate();
     needs_descendant_dependent_flags_update_ = false;
   }
 
   bool previously_has_visible_content = has_visible_content_;
@@ skipping 2028 matching lines @@
            ((global_paint_flags & kGlobalPaintFlattenCompositingLayers) ||
             GetCompositingState() != kPaintsIntoOwnBacking);
   }
 
   return (Transform() ||
           GetLayoutObject().Style()->GetPosition() == EPosition::kFixed) &&
          ((global_paint_flags & kGlobalPaintFlattenCompositingLayers) ||
           GetCompositingState() != kPaintsIntoOwnBacking);
 }
 
+bool PaintLayer::SupportsSubsequenceCaching() const {

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

Can you add a DCHECK in SubsequenceRecorder that SupportsSubsequenceCaching is
true?

Similarly, can you DCHECK that the parent has
HasDescendantThatSupportsSubsequenceCaching()?

[chrishtr, 2017/04/13 02:05:59]

Done.

+  // SVG paints atomically.
+  if (GetLayoutObject().IsSVGRoot())
+    return true;
+
+  // Create subsequence for only stacking contexts whose painting are atomic.
+  if (!StackingNode()->IsStackingContext())
+    return false;
+
+  // The layer doesn't have children. Subsequence caching is not worth it,
+  // because normally the actual painting will be cheap.
+  // SVG is also painted atomically.
+  if (!PaintLayerStackingNodeIterator(*StackingNode(), kAllChildren).Next())
+    return false;
+
+  return true;
+}
+
 bool PaintLayer::CompositesWithTransform() const {
   return TransformAncestor() || Transform();
 }
 
 bool PaintLayer::CompositesWithOpacity() const {
   return OpacityAncestor() || GetLayoutObject().Style()->HasOpacity();
 }
 
 bool PaintLayer::BackgroundIsKnownToBeOpaqueInRect(
     const LayoutRect& local_rect) const {
@@ skipping 517 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->EnclosingLayer());
 }
 #endif