cc: Don't perform image analysis if the DisplayItemList has no images.

cc/paint/paint_op_buffer.h

 // 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.
 
 #ifndef CC_PAINT_PAINT_OP_BUFFER_H_
 #define CC_PAINT_PAINT_OP_BUFFER_H_
 
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 67 matching lines @@
 
   PaintOpType GetType() const { return static_cast<PaintOpType>(type); }
 
   void Raster(SkCanvas* canvas, const SkMatrix& original_ctm) const;
   bool IsDrawOp() const;
 
   // Only valid for draw ops.
   void RasterWithAlpha(SkCanvas* canvas, uint8_t alpha) const;
 
   int CountSlowPaths() const { return 0; }
+  bool HasDiscardableImages() const { return false; }
 
   // Returns the number of bytes used by this op in referenced sub records
   // and display lists.  This doesn't count other objects like paths or blobs.
   size_t AdditionalBytesUsed() const { return 0; }
 
   static constexpr bool kIsDrawOp = false;
   // If an op has |kHasPaintFlags| set to true, it must:
   // (1) Provide a PaintFlags member called |flags|
   // (2) Provide a RasterWithFlags function instead of a Raster function.
   static constexpr bool kHasPaintFlags = false;
@@ skipping 176 matching lines @@
   static constexpr bool kIsDrawOp = true;
   explicit DrawDisplayItemListOp(scoped_refptr<DisplayItemList> list);
   // Windows wants to generate these when types are exported, so
   // provide them here explicitly so that DisplayItemList doesn't have
   // to be defined in this header.
   DrawDisplayItemListOp(const DrawDisplayItemListOp& op);
   DrawDisplayItemListOp& operator=(const DrawDisplayItemListOp& op);
   ~DrawDisplayItemListOp();
   void Raster(SkCanvas* canvas) const;
   size_t AdditionalBytesUsed() const;
+  bool HasDiscardableImages() const;
   // TODO(enne): DisplayItemList should know number of slow paths.
 
   scoped_refptr<DisplayItemList> list;
 };
 
 struct CC_PAINT_EXPORT DrawDRRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawDRRect;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawDRRectOp(const SkRRect& outer,
@@ skipping 10 matching lines @@
 struct CC_PAINT_EXPORT DrawImageOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawImage;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawImageOp(const PaintImage& image,
               SkScalar left,
               SkScalar top,
               const PaintFlags* flags);
   ~DrawImageOp();
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
+  bool HasDiscardableImages() const;
 
   PaintImage image;
   SkScalar left;
   SkScalar top;
   PaintFlags flags;
 };
 
 struct CC_PAINT_EXPORT DrawImageRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawImageRect;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawImageRectOp(const PaintImage& image,
                   const SkRect& src,
                   const SkRect& dst,
                   const PaintFlags* flags,
                   PaintCanvas::SrcRectConstraint constraint);
   ~DrawImageRectOp();
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
+  bool HasDiscardableImages() const;
 
   PaintImage image;
   PaintFlags flags;
   SkRect src;
   SkRect dst;
   PaintCanvas::SrcRectConstraint constraint;
 };
 
 struct CC_PAINT_EXPORT DrawIRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawIRect;
@@ skipping 63 matching lines @@
   PaintFlags flags;
 };
 
 struct CC_PAINT_EXPORT DrawRecordOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawRecord;
   static constexpr bool kIsDrawOp = true;
   explicit DrawRecordOp(sk_sp<const PaintRecord> record);
   ~DrawRecordOp();
   void Raster(SkCanvas* canvas) const;
   size_t AdditionalBytesUsed() const;
+  bool HasDiscardableImages() const;
 
   sk_sp<const PaintRecord> record;
 };
 
 struct CC_PAINT_EXPORT DrawRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawRect;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawRectOp(const SkRect& rect, const PaintFlags& flags)
       : rect(rect), flags(flags) {}
@@ skipping 138 matching lines @@
 
   void playback(SkCanvas* canvas) const;
   void playback(SkCanvas* canvas, SkPicture::AbortCallback* callback) const;
 
   // TODO(enne): These are no longer approximate.  Rename these.
   int approximateOpCount() const { return op_count_; }
   size_t approximateBytesUsed() const {
     return sizeof(*this) + reserved_ + subrecord_bytes_used_;
   }
   int numSlowPaths() const { return num_slow_paths_; }
+  bool HasDiscardableImages() const { return has_discardable_images_; }
 
   // Resize the PaintOpBuffer to exactly fit the current amount of used space.
   void ShrinkToFit();
 
   const SkRect& cullRect() const { return cull_rect_; }
 
   PaintOp* GetFirstOp() const {
     return const_cast<PaintOp*>(first_op_.data_as<PaintOp>());
   }
 
@@ skipping 131 matching lines @@
   template <typename T, bool HasFlags>
   struct CountSlowPathsFromFlags {
     static int Count(const T* op) { return 0; }
   };
 
   template <typename T>
   struct CountSlowPathsFromFlags<T, true> {
     static int Count(const T* op) { return op->flags.getPathEffect() ? 1 : 0; }
   };
 
+  template <typename T, bool HasFlags>
+  struct HasDiscardableImagesFromFlags {
+    static bool HasDiscardableImages(const T* op) { return false; }
+  };
+
+  template <typename T>
+  struct HasDiscardableImagesFromFlags<T, true> {
+    static bool HasDiscardableImages(const T* op) {
+      if (!op->kIsDrawOp)
+        return false;
+
+      SkShader* shader = op->flags.getShader();
+      SkImage* image = shader ? shader->isAImage(nullptr, nullptr) : nullptr;
+      return image ? image->isLazyGenerated() : false;

[vmpstr, 2017/04/25 17:43:40]

return image && image->isLazyGenerated();

+    }
+  };
+
   template <typename T, typename... Args>
   T* push_internal(size_t bytes, Args&&... args) {
     size_t skip = SkAlignPtr(sizeof(T) + bytes);
     DCHECK_LT(skip, static_cast<size_t>(1) << 24);
     if (used_ + skip > reserved_ || !op_count_) {
       if (!op_count_) {
         if (bytes) {
           // Internal first_op buffer doesn't have room for extra data.
           // If the op wants extra bytes, then we'll just store a Noop
           // in the first_op and proceed from there.  This seems unlikely
           // to be a common case.
           push<NoopOp>();
         } else {
           // |first_op_| is aligned to LargestPaintOp. If T needs a smaller
           // alignment, this is okay because it will be a factor of the actual
           // alignment being used (as they are always a power of 2). If T needs
           // a larger alignment, that is bad and we should use T to choose the
           // alignment of |first_op_| instead.
           static_assert(ALIGNOF(T) <= ALIGNOF(LargestPaintOp), "");
           auto* op = reinterpret_cast<T*>(first_op_.data_as<T>());
           new (op) T{std::forward<Args>(args)...};
           op->type = static_cast<uint32_t>(T::kType);
           op->skip = 0;
           op_count_++;
+          AnalyzeAddedOp(op);
           return op;
         }
       }
 
       // Start reserved_ at kInitialBufferSize and then double.
       // ShrinkToFit can make this smaller afterwards.
       while (used_ + skip > reserved_)
         reserved_ = reserved_ ? reserved_ * 2 : kInitialBufferSize;
       data_.realloc(reserved_);
     }
     DCHECK_LE(used_ + skip, reserved_);
 
     T* op = reinterpret_cast<T*>(data_.get() + used_);
     used_ += skip;
     new (op) T(std::forward<Args>(args)...);
     op->type = static_cast<uint32_t>(T::kType);
     op->skip = skip;
     op_count_++;
+    AnalyzeAddedOp(op);
+    return op;
+  }
 
+  template <typename T>
+  void AnalyzeAddedOp(const T* op) {
     num_slow_paths_ += CountSlowPathsFromFlags<T, T::kHasPaintFlags>::Count(op);
     num_slow_paths_ += op->CountSlowPaths();
 
+    has_discardable_images_ |= op->HasDiscardableImages();
+    has_discardable_images_ |= HasDiscardableImagesFromFlags<
+        T, T::kHasPaintFlags>::HasDiscardableImages(op);
+
     subrecord_bytes_used_ += op->AdditionalBytesUsed();
-
-    return op;
   }
 
   // As a performance optimization because n=1 is an extremely common case just
   // store the first op in the PaintOpBuffer itself to avoid an extra alloc.
   base::AlignedMemory<sizeof(LargestPaintOp), ALIGNOF(LargestPaintOp)>
       first_op_;
   SkAutoTMalloc<char> data_;
   size_t used_ = 0;
   size_t reserved_ = 0;
   int op_count_ = 0;
 
   // Record paths for veto-to-msaa for gpu raster.
   int num_slow_paths_ = 0;
   // Record additional bytes used by referenced sub-records and display lists.
   size_t subrecord_bytes_used_ = 0;
+  bool has_discardable_images_ = false;
   SkRect cull_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(PaintOpBuffer);
 };
 
 }  // namespace cc
 
 #endif  // CC_PAINT_PAINT_OP_BUFFER_H_