Use SaveLayerAlpha bounds when doing Save-Draw-Restore optimization

cc/paint/paint_op_buffer.cc

 // Copyright 2017 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 "cc/paint/paint_op_buffer.h"
 
 #include "base/containers/stack_container.h"
 #include "cc/paint/display_item_list.h"
 #include "cc/paint/paint_record.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
@@ skipping 37 matching lines @@
                                 SkCanvas* canvas,
                                 const SkMatrix& original_ctm);
 using RasterWithFlagsFunction = void (*)(const PaintOpWithFlags* op,
                                          const PaintFlags* flags,
                                          SkCanvas* canvas,
                                          const SkMatrix& original_ctm);
 
 NOINLINE static void RasterWithAlphaInternal(RasterFunction raster_fn,
                                              const PaintOp* op,
                                              SkCanvas* canvas,
+                                             const SkRect& bounds,
                                              uint8_t alpha) {
-  // TODO(enne): is it ok to just drop the bounds here?
-  canvas->saveLayerAlpha(nullptr, alpha);
+  bool unset = bounds.x() == PaintOp::kUnsetRect.x();
+  canvas->saveLayerAlpha(unset ? nullptr : &bounds, alpha);
   SkMatrix unused_matrix;
   raster_fn(op, canvas, unused_matrix);
   canvas->restore();
 }
 
 // Helper template to share common code for RasterWithAlpha when paint ops
 // have or don't have PaintFlags.
 template <typename T, bool HasFlags>
 struct Rasterizer {
-  static void RasterWithAlpha(const T* op, SkCanvas* canvas, uint8_t alpha) {
+  static void RasterWithAlpha(const T* op,
+                              SkCanvas* canvas,
+                              const SkRect& bounds,
+                              uint8_t alpha) {
     static_assert(
         !T::kHasPaintFlags,
         "This function should not be used for a PaintOp that has PaintFlags");
     DCHECK(T::kIsDrawOp);
-    RasterWithAlphaInternal(&T::Raster, op, canvas, alpha);
+    RasterWithAlphaInternal(&T::Raster, op, canvas, bounds, alpha);
   }
 };
 
 NOINLINE static void RasterWithAlphaInternalForFlags(
     RasterWithFlagsFunction raster_fn,
     const PaintOpWithFlags* op,
     SkCanvas* canvas,
+    const SkRect& bounds,
     uint8_t alpha) {
   SkMatrix unused_matrix;
   if (alpha == 255) {
     raster_fn(op, &op->flags, canvas, unused_matrix);
   } else if (op->flags.SupportsFoldingAlpha()) {
     PaintFlags flags = op->flags;
     flags.setAlpha(SkMulDiv255Round(flags.getAlpha(), alpha));
     raster_fn(op, &flags, canvas, unused_matrix);
   } else {
-    canvas->saveLayerAlpha(nullptr, alpha);
+    bool unset = bounds.x() == PaintOp::kUnsetRect.x();
+    canvas->saveLayerAlpha(unset ? nullptr : &bounds, alpha);
     raster_fn(op, &op->flags, canvas, unused_matrix);
     canvas->restore();
   }
 }
 
 template <typename T>
 struct Rasterizer<T, true> {
-  static void RasterWithAlpha(const T* op, SkCanvas* canvas, uint8_t alpha) {
+  static void RasterWithAlpha(const T* op,
+                              SkCanvas* canvas,
+                              const SkRect& bounds,
+                              uint8_t alpha) {
     static_assert(T::kHasPaintFlags,
                   "This function expects the PaintOp to have PaintFlags");
     DCHECK(T::kIsDrawOp);
-    RasterWithAlphaInternalForFlags(&T::RasterWithFlags, op, canvas, alpha);
+    RasterWithAlphaInternalForFlags(&T::RasterWithFlags, op, canvas, bounds,
+                                    alpha);
   }
 };
 
 template <>
 struct Rasterizer<DrawRecordOp, false> {
   static void RasterWithAlpha(const DrawRecordOp* op,
                               SkCanvas* canvas,
+                              const SkRect& bounds,
                               uint8_t alpha) {
     // This "looking into records" optimization is done here instead of
     // in the PaintOpBuffer::Raster function as DisplayItemList calls
     // into RasterWithAlpha directly.
     if (op->record->size() == 1u) {
       PaintOp* single_op = op->record->GetFirstOp();
       // RasterWithAlpha only supported for draw ops.
       if (single_op->IsDrawOp()) {
-        single_op->RasterWithAlpha(canvas, alpha);
+        single_op->RasterWithAlpha(canvas, bounds, alpha);
         return;
       }
     }
 
-    canvas->saveLayerAlpha(nullptr, alpha);
+    bool unset = bounds.x() == PaintOp::kUnsetRect.x();
+    canvas->saveLayerAlpha(unset ? nullptr : &bounds, alpha);
     SkMatrix unused_matrix;
     DrawRecordOp::Raster(op, canvas, unused_matrix);
     canvas->restore();
   }
 };
 
 // TODO(enne): partially specialize RasterWithAlpha for draw color?
 
 static constexpr size_t kNumOpTypes =
     static_cast<size_t>(PaintOpType::LastPaintOpType) + 1;
 
 // Verify that every op is in the TYPES macro.
 #define M(T) +1
 static_assert(kNumOpTypes == TYPES(M), "Missing op in list");
 #undef M
 
 using RasterFunction = void (*)(const PaintOp* op,
                                 SkCanvas* canvas,
                                 const SkMatrix& original_ctm);
 #define M(T) &T::Raster,
 static const RasterFunction g_raster_functions[kNumOpTypes] = {TYPES(M)};
 #undef M
 
 using RasterAlphaFunction = void (*)(const PaintOp* op,
                                      SkCanvas* canvas,
+                                     const SkRect& bounds,
                                      uint8_t alpha);
 #define M(T) \
-  T::kIsDrawOp ? \
-  [](const PaintOp* op, SkCanvas* canvas, uint8_t alpha) { \
+  T::kIsDrawOp ? [](const PaintOp* op, SkCanvas* canvas, const SkRect& bounds, \
+                    uint8_t alpha) { \
     Rasterizer<T, T::kHasPaintFlags>::RasterWithAlpha( \
-        static_cast<const T*>(op), canvas, alpha); \
+        static_cast<const T*>(op), canvas, bounds, alpha); \
   } : static_cast<RasterAlphaFunction>(nullptr),
 static const RasterAlphaFunction g_raster_alpha_functions[kNumOpTypes] = {
     TYPES(M)};
 #undef M
 
 // Most state ops (matrix, clip, save, restore) have a trivial destructor.
 // TODO(enne): evaluate if we need the nullptr optimization or if
 // we even need to differentiate trivial destructors here.
 using VoidFunction = void (*)(PaintOp* op);
 #define M(T)                                           \
@@ skipping 272 matching lines @@
 }
 
 bool PaintOp::IsDrawOp() const {
   return g_is_draw_op[type];
 }
 
 void PaintOp::Raster(SkCanvas* canvas, const SkMatrix& original_ctm) const {
   g_raster_functions[type](this, canvas, original_ctm);
 }
 
-void PaintOp::RasterWithAlpha(SkCanvas* canvas, uint8_t alpha) const {
-  g_raster_alpha_functions[type](this, canvas, alpha);
+void PaintOp::RasterWithAlpha(SkCanvas* canvas,
+                              const SkRect& bounds,
+                              uint8_t alpha) const {
+  g_raster_alpha_functions[type](this, canvas, bounds, alpha);
 }
 
 int ClipPathOp::CountSlowPaths() const {
   return antialias && !path.isConvex() ? 1 : 0;
 }
 
 int DrawLineOp::CountSlowPaths() const {
   if (const SkPathEffect* effect = flags.getPathEffect()) {
     SkPathEffect::DashInfo info;
     SkPathEffect::DashType dashType = effect->asADash(&info);
@@ skipping 247 matching lines @@
       if (second) {
         if (second->GetType() == PaintOpType::Restore) {
           continue;
         }
         if (second->IsDrawOp()) {
           third =
               NextOp(range_starts, range_indices, &stack, &iter, &range_index);
           if (third && third->GetType() == PaintOpType::Restore) {
             const SaveLayerAlphaOp* save_op =
                 static_cast<const SaveLayerAlphaOp*>(op);
-            second->RasterWithAlpha(canvas, save_op->alpha);
+            second->RasterWithAlpha(canvas, save_op->bounds, save_op->alpha);
             continue;
           }
         }
 
         // Store deferred ops for later.
         stack->push_back(second);
         if (third)
           stack->push_back(third);
       }
     }
@@ skipping 55 matching lines @@
   return std::make_pair(op, skip);
 }
 
 void PaintOpBuffer::ShrinkToFit() {
   if (!used_ || used_ == reserved_)
     return;
   ReallocBuffer(used_);
 }
 
 }  // namespace cc