Only store previous clip rects for PaintLayers that support subsequences.

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

 // Copyright 2014 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/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
 #include "core/paint/FilterPainter.h"
@@ skipping 149 matching lines @@
 }
 
 static bool ShouldCreateSubsequence(const PaintLayer& paint_layer,
                                     const GraphicsContext& context,
                                     const PaintLayerPaintingInfo& painting_info,
                                     PaintLayerFlags paint_flags) {
   // Caching is not needed during printing.
   if (context.Printing())
     return false;
 
+  if (!paint_layer.SupportsSubsequenceCaching())
+    return false;
+
   // Don't create subsequence for a composited layer because if it can be
   // cached, we can skip the whole painting in GraphicsLayer::paint() with
   // CachedDisplayItemList.  This also avoids conflict of
   // PaintLayer::previousXXX() when paintLayer is composited scrolling and is
   // painted twice for GraphicsLayers of container and scrolling contents.
   if (paint_layer.GetCompositingState() == kPaintsIntoOwnBacking)
     return false;
 
   // Don't create subsequence during special painting to avoid cache conflict
   // with normal painting.
   if (painting_info.GetGlobalPaintFlags() &
       kGlobalPaintFlattenCompositingLayers)
     return false;
   if (paint_flags &
       (kPaintLayerPaintingRootBackgroundOnly |
        kPaintLayerPaintingOverlayScrollbars | kPaintLayerUncachedClipRects))
     return false;
 
-  // Create subsequence for only stacking contexts whose painting are atomic.
-  // SVG is also painted atomically.
-  if (!paint_layer.StackingNode()->IsStackingContext() &&
-      !paint_layer.GetLayoutObject().IsSVGRoot())
-    return false;
-
-  // The layer doesn't have children. Subsequence caching is not worth because
-  // normally the actual painting will be cheap.
-  // SVG is also painted atomically.
-  if (!PaintLayerStackingNodeIterator(*paint_layer.StackingNode(), kAllChildren)
-           .Next() &&
-      !paint_layer.GetLayoutObject().IsSVGRoot())
-    return false;
-
   // When in FOUC-avoidance mode, don't cache any subsequences, to avoid having
   // to invalidate all of them when leaving this mode. There is an early-out in
   // BlockPainter::paintContents that may result in nothing getting painted in
   // this mode, in addition to early-out logic in PaintLayerPainter.
   if (paint_layer.GetLayoutObject()
           .GetDocument()
           .DidLayoutWithPendingStylesheets())
     return false;
 
   return true;
@@ skipping 127 matching lines @@
   Optional<SubsequenceRecorder> subsequence_recorder;
   bool should_clear_empty_paint_phase_flags = false;
   if (ShouldCreateSubsequence(paint_layer_, context, painting_info_arg,
                               paint_flags)) {
     if (!ShouldRepaintSubsequence(paint_layer_, painting_info_arg,
                                   respect_overflow_clip, subpixel_accumulation,
                                   should_clear_empty_paint_phase_flags) &&
         SubsequenceRecorder::UseCachedSubsequenceIfPossible(context,
                                                             paint_layer_))
       return result;
+    DCHECK(paint_layer_.SupportsSubsequenceCaching());
     subsequence_recorder.emplace(context, paint_layer_);
   } else {
     should_clear_empty_paint_phase_flags = true;
   }
 
   if (should_clear_empty_paint_phase_flags) {
     paint_layer_.SetPreviousPaintPhaseDescendantOutlinesEmpty(false);
     paint_layer_.SetPreviousPaintPhaseFloatEmpty(false);
     paint_layer_.SetPreviousPaintPhaseDescendantBlockBackgroundsEmpty(false);
   }
@@ skipping 869 matching lines @@
           context, layout_object, kPaintPhaseClippingMask))
     return;
 
   IntRect snapped_clip_rect = PixelSnappedIntRect(clip_rect.Rect());
   LayoutObjectDrawingRecorder drawing_recorder(
       context, layout_object, kPaintPhaseClippingMask, snapped_clip_rect);
   context.FillRect(snapped_clip_rect, Color::kBlack);
 }
 
 }  // namespace blink