cc: Add image decode control in the compositor.

cc/playback/discardable_image_map.cc

 // 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 "cc/playback/discardable_image_map.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "cc/base/math_util.h"
 #include "cc/playback/display_item_list.h"
 #include "third_party/skia/include/utils/SkNWayCanvas.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 
-namespace {
-
 SkRect MapRect(const SkMatrix& matrix, const SkRect& src) {
   SkRect dst;
   matrix.mapRect(&dst, src);
   return dst;
 }
 
-SkSize ExtractScale(const SkMatrix& matrix) {
-  SkSize scale = SkSize::Make(matrix.getScaleX(), matrix.getScaleY());
+bool ExtractScale(const SkMatrix& matrix, SkSize* scale) {
+  *scale = SkSize::Make(matrix.getScaleX(), matrix.getScaleY());
   if (matrix.getType() & SkMatrix::kAffine_Mask) {
-    if (!matrix.decomposeScale(&scale))
-      scale.set(1, 1);
+    if (!matrix.decomposeScale(scale)) {
+      scale->set(1, 1);
+      return false;
+    }
   }
-  return scale;
+  return true;
 }
 
+namespace {
+
 // We're using an NWay canvas with no added canvases, so in effect
 // non-overridden functions are no-ops.
 class DiscardableImagesMetadataCanvas : public SkNWayCanvas {
  public:
   DiscardableImagesMetadataCanvas(
       int width,
       int height,
       std::vector<std::pair<DrawImage, gfx::RectF>>* image_set)
       : SkNWayCanvas(width, height),
         image_set_(image_set),
@@ skipping 40 matching lines @@
                        const SkRect& dst,
                        const SkPaint* paint) override {
     AddImage(image, dst, this->getTotalMatrix(), paint);
   }
 
  private:
   void AddImage(const SkImage* image,
                 const SkRect& rect,
                 const SkMatrix& matrix,
                 const SkPaint* paint) {
-    if (rect.intersects(canvas_bounds_) && image->isLazyGenerated()) {
-      SkFilterQuality filter_quality = kNone_SkFilterQuality;
-      if (paint) {
-        filter_quality = paint->getFilterQuality();
+    if (!image->isLazyGenerated())
+      return;
+
+    SkRect paint_rect = rect;
+    if (paint) {
+      if (paint->canComputeFastBounds()) {
+        paint_rect = paint->computeFastBounds(rect, &paint_rect);
+      } else {
+        // TODO(vmpstr): UMA this case.
+        paint_rect = canvas_bounds_;
       }
-      image_set_->push_back(
-          std::make_pair(DrawImage(image, ExtractScale(matrix), filter_quality),
-                         gfx::SkRectToRectF(rect)));
     }
+
+    if (!rect.intersects(canvas_bounds_))
+      return;
+
+    SkFilterQuality filter_quality = kNone_SkFilterQuality;
+    if (paint) {
+      filter_quality = paint->getFilterQuality();
+    }
+
+    SkSize scale;
+    bool is_decomposable = ExtractScale(matrix, &scale);
+    image_set_->push_back(
+        std::make_pair(DrawImage(image, scale, filter_quality,
+                                 matrix.hasPerspective(), is_decomposable),
+                       gfx::SkRectToRectF(rect)));
   }
 
   std::vector<std::pair<DrawImage, gfx::RectF>>* image_set_;
   const SkRect canvas_bounds_;
 };
 
 }  // namespace
 
 DiscardableImageMap::DiscardableImageMap() {}
 
@@ skipping 25 matching lines @@
     DiscardableImageMap* image_map,
     const gfx::Size& bounds)
     : image_map_(image_map),
       metadata_canvas_(image_map->BeginGeneratingMetadata(bounds)) {}
 
 DiscardableImageMap::ScopedMetadataGenerator::~ScopedMetadataGenerator() {
   image_map_->EndGeneratingMetadata();
 }
 
 }  // namespace cc