cc: Add image decode control in the compositor.

cc/playback/display_list_raster_source.cc

 // 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 "cc/playback/display_list_raster_source.h"
 
+#include "base/containers/adapters.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
+#include "cc/playback/discardable_image_map.h"
 #include "cc/playback/display_item_list.h"
+#include "cc/tiles/image_decode_controller.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
+#include "third_party/skia/include/utils/SkNWayCanvas.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
+namespace {
+
+SkIRect RoundOutRect(const SkRect& rect) {
+  SkIRect result;
+  rect.roundOut(&result);
+  return result;
+}
+
+class ImageHijackCanvas : public SkNWayCanvas {
+ public:
+  ImageHijackCanvas(int width,
+                    int height,
+                    ImageDecodeController* image_decode_controller)
+      : SkNWayCanvas(width, height),
+        image_decode_controller_(image_decode_controller),
+        canvas_bounds_(SkRect::MakeIWH(width, height)) {}
+
+ protected:
+  // Ensure that pictures are unpacked by this canvas, instead of being
+  // forwarded to the raster canvas.
+  void onDrawPicture(const SkPicture* picture,
+                     const SkMatrix* matrix,
+                     const SkPaint* paint) override {
+    SkCanvas::onDrawPicture(picture, matrix, paint);
+  }
+
+  void onDrawImage(const SkImage* image,
+                   SkScalar x,
+                   SkScalar y,
+                   const SkPaint* paint) override {
+    if (!image->isLazyGenerated()) {
+      SkNWayCanvas::onDrawImage(image, x, y, paint);
+      return;
+    }
+
+    SkMatrix ctm = getTotalMatrix();
+    SkRect paint_bounds;
+    bool computed_paint_bounds = ComputePaintBounds(
+        SkRect::MakeXYWH(x, y, image->width(), image->height()), paint,
+        &paint_bounds);
+    if (computed_paint_bounds && !canvas_bounds_.intersects(paint_bounds))
+      return;

[enne (OOO), 2015/12/08 23:27:24]

I'm a little confused why this check and paint inspection needs to happen at
raster time.  Doesn't the rtree already know which image ops fit in the right
place?

What use case are you trying to optimize for here?

[vmpstr, 2015/12/09 23:53:41]

I guess this is more of a safety check, since we could be using our own rtree,
or skia's rtree or no rtree at all, and the consequences of us not doing exactly
what the discardable image map does is that we'll decode things in place.

For example the drop shadow case I had would have not been caught if it wasn't
for this type of situation and instead would've been happily decoded in place
(causing bad performance instead of a correctness issue).

I can remove this if you prefer, but it feels somewhat safer to keep it.

[enne (OOO), 2015/12/10 00:07:16]

Safer, but also a needless cost per image draw.

I think if you analyze a picture and the analysis says these are the pictures in
this rect, then you go to draw that rect, you don't need to also double check
later to make sure the pictures are there.  

Or, if you are going to, it should be a dcheck and not an early out, and should
be cheap in release.

[vmpstr, 2015/12/10 00:47:03]

Sounds good. I've removed this, since it was adding a lot of code and it's hard
to make it DCHECK only (canvas overrides for saving the paints). We can re-add
that if we start finding that we're leaking images that weren't predecoded.

+
+    SkSize scale;
+    bool is_decomposable = ExtractScale(ctm, &scale);
+    ScopedDecodedImageLock scoped_lock(
+        image_decode_controller_, image,
+        SkRect::MakeIWH(image->width(), image->height()), scale,
+        is_decomposable, ctm.hasPerspective(), paint);
+    const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
+    DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().width()));
+    DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().height()));
+    const SkPaint* decoded_paint = scoped_lock.decoded_paint();
+
+    bool need_scale = !decoded_image.is_scale_adjustment_identity();
+    if (need_scale) {
+      SkNWayCanvas::save();
+      SkNWayCanvas::scale(1.f / (decoded_image.scale_adjustment().width()),
+                          1.f / (decoded_image.scale_adjustment().height()));
+    }
+    SkNWayCanvas::onDrawImage(decoded_image.image(), x, y, decoded_paint);
+    if (need_scale)
+      SkNWayCanvas::restore();
+  }
+
+  void onDrawImageRect(const SkImage* image,
+                       const SkRect* src,
+                       const SkRect& dst,
+                       const SkPaint* paint,
+                       SrcRectConstraint constraint) override {
+    if (!image->isLazyGenerated()) {
+      SkNWayCanvas::onDrawImageRect(image, src, dst, paint, constraint);
+      return;
+    }
+
+    SkMatrix ctm = getTotalMatrix();
+    SkRect paint_bounds;
+    bool computed_paint_bounds =
+        ComputePaintBounds(MapRect(ctm, dst), paint, &paint_bounds);
+    if (computed_paint_bounds && !canvas_bounds_.intersects(paint_bounds))
+      return;
+
+    SkRect src_storage;
+    if (!src) {
+      src_storage = SkRect::MakeIWH(image->width(), image->height());
+      src = &src_storage;
+    }
+    SkMatrix matrix;
+    matrix.setRectToRect(*src, dst, SkMatrix::kFill_ScaleToFit);
+    matrix.postConcat(ctm);
+
+    SkSize scale;
+    bool is_decomposable = ExtractScale(matrix, &scale);
+    ScopedDecodedImageLock scoped_lock(image_decode_controller_, image, *src,
+                                       scale, is_decomposable,
+                                       matrix.hasPerspective(), paint);
+    const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
+    const SkPaint* decoded_paint = scoped_lock.decoded_paint();
+
+    SkRect adjusted_src =
+        src->makeOffset(decoded_image.src_rect_offset().width(),
+                        decoded_image.src_rect_offset().height());
+    if (!decoded_image.is_scale_adjustment_identity()) {
+      float x_scale = decoded_image.scale_adjustment().width();
+      float y_scale = decoded_image.scale_adjustment().height();
+      adjusted_src = SkRect::MakeXYWH(
+          adjusted_src.x() * x_scale, adjusted_src.y() * y_scale,
+          adjusted_src.width() * x_scale, adjusted_src.height() * y_scale);
+    }
+    SkNWayCanvas::onDrawImageRect(decoded_image.image(), &adjusted_src, dst,
+                                  decoded_paint, constraint);
+  }
+
+  void onDrawImageNine(const SkImage* image,
+                       const SkIRect& center,
+                       const SkRect& dst,
+                       const SkPaint* paint) override {
+    // TODO(vmpstr): Maybe this should just call drawImageRect several times.
+    // Does Blink use this?

[enne (OOO), 2015/12/08 23:27:24]

grep suggests no.  If we don't have any testing that this code is right, I'd
rather just NOTREACHED it?

[vmpstr, 2015/12/09 23:53:41]

Done.

+    if (!image->isLazyGenerated()) {
+      SkNWayCanvas::onDrawImageNine(image, center, dst, paint);
+      return;
+    }
+
+    SkRect paint_bounds;
+    bool computed_paint_bounds = ComputePaintBounds(dst, paint, &paint_bounds);
+    if (computed_paint_bounds && !canvas_bounds_.intersects(paint_bounds))
+      return;
+
+    SkMatrix ctm = getTotalMatrix();
+    SkSize scale;
+    bool is_decomposable = ExtractScale(ctm, &scale);
+    ScopedDecodedImageLock scoped_lock(
+        image_decode_controller_, image,
+        SkRect::MakeIWH(image->width(), image->height()), scale,
+        is_decomposable, ctm.hasPerspective(), paint);
+    const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
+    DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().width()));
+    DCHECK_EQ(0, static_cast<int>(decoded_image.src_rect_offset().height()));
+    const SkPaint* decoded_paint = scoped_lock.decoded_paint();
+
+    SkIRect adjusted_center = center;
+    if (!decoded_image.is_scale_adjustment_identity()) {
+      float x_scale = decoded_image.scale_adjustment().width();
+      float y_scale = decoded_image.scale_adjustment().height();
+      adjusted_center = SkIRect::MakeXYWH(
+          static_cast<int>(std::floor(center.x() * x_scale)),
+          static_cast<int>(std::floor(center.y() * y_scale)),
+          static_cast<int>(std::ceil(center.width() * x_scale)),
+          static_cast<int>(std::ceil(center.height() * y_scale)));
+    }
+    SkNWayCanvas::onDrawImageNine(decoded_image.image(), adjusted_center, dst,
+                                  decoded_paint);
+  }
+
+  SaveLayerStrategy willSaveLayer(const SkRect* rect,
+                                  const SkPaint* paint,
+                                  SaveFlags save_flags) override {
+    saved_paints_.push_back(paint);
+    return SkNWayCanvas::willSaveLayer(rect, paint, save_flags);
+  }
+
+  void willSave() override {
+    saved_paints_.push_back(nullptr);
+    return SkNWayCanvas::willSave();
+  }
+
+  void willRestore() override {
+    DCHECK_GT(saved_paints_.size(), 0u);
+    saved_paints_.pop_back();
+    SkNWayCanvas::willRestore();
+  }
+
+ private:
+  class ScopedDecodedImageLock {
+   public:
+    ScopedDecodedImageLock(ImageDecodeController* image_decode_controller,
+                           const SkImage* image,
+                           const SkRect& src_rect,
+                           const SkSize& scale,
+                           bool is_decomposable,
+                           bool has_perspective,
+                           const SkPaint* paint)
+        : image_decode_controller_(image_decode_controller),
+          paint_(paint),
+          draw_image_(image,
+                      RoundOutRect(src_rect),
+                      scale,
+                      paint ? paint->getFilterQuality() : kNone_SkFilterQuality,
+                      has_perspective,
+                      is_decomposable),
+          decoded_draw_image_(
+              image_decode_controller_->GetDecodedImageForDraw(draw_image_)) {
+      DCHECK(image->isLazyGenerated());
+      if (paint) {
+        decoded_paint_ = *paint;
+        decoded_paint_.setFilterQuality(decoded_draw_image_.filter_quality());
+      }
+    }
+
+    ~ScopedDecodedImageLock() {
+      image_decode_controller_->DrawWithImageFinished(draw_image_,
+                                                      decoded_draw_image_);
+    }
+
+    const DecodedDrawImage& decoded_image() const {
+      return decoded_draw_image_;
+    }
+    const SkPaint* decoded_paint() const {
+      return paint_ ? &decoded_paint_ : nullptr;
+    }
+
+   private:
+    ImageDecodeController* image_decode_controller_;
+    const SkPaint* paint_;
+    DrawImage draw_image_;
+    DecodedDrawImage decoded_draw_image_;
+    SkPaint decoded_paint_;
+  };
+
+  bool ComputePaintBounds(const SkRect& rect,
+                          const SkPaint* paint,
+                          SkRect* paint_bounds) {
+    return ComputeNewRectFromPaintBounds(rect, paint, saved_paints_,
+                                         paint_bounds);
+  }
+
+  ImageDecodeController* image_decode_controller_;
+  const SkRect canvas_bounds_;
+  std::vector<const SkPaint*> saved_paints_;
+};
+
+}  // namespace
+
 scoped_refptr<DisplayListRasterSource>
 DisplayListRasterSource::CreateFromDisplayListRecordingSource(
     const DisplayListRecordingSource* other,
     bool can_use_lcd_text) {
   return make_scoped_refptr(
       new DisplayListRasterSource(other, can_use_lcd_text));
 }
 
 DisplayListRasterSource::DisplayListRasterSource(
     const DisplayListRecordingSource* other,
     bool can_use_lcd_text)
     : display_list_(other->display_list_),
       painter_reported_memory_usage_(other->painter_reported_memory_usage_),
       background_color_(other->background_color_),
       requires_clear_(other->requires_clear_),
       can_use_lcd_text_(can_use_lcd_text),
       is_solid_color_(other->is_solid_color_),
       solid_color_(other->solid_color_),
       recorded_viewport_(other->recorded_viewport_),
       size_(other->size_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
       slow_down_raster_scale_factor_for_debug_(
           other->slow_down_raster_scale_factor_for_debug_),
-      should_attempt_to_use_distance_field_text_(false) {}
+      should_attempt_to_use_distance_field_text_(false),
+      image_decode_controller_(nullptr) {}
 
 DisplayListRasterSource::DisplayListRasterSource(
     const DisplayListRasterSource* other,
     bool can_use_lcd_text)
     : display_list_(other->display_list_),
       painter_reported_memory_usage_(other->painter_reported_memory_usage_),
       background_color_(other->background_color_),
       requires_clear_(other->requires_clear_),
       can_use_lcd_text_(can_use_lcd_text),
       is_solid_color_(other->is_solid_color_),
       solid_color_(other->solid_color_),
       recorded_viewport_(other->recorded_viewport_),
       size_(other->size_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
       slow_down_raster_scale_factor_for_debug_(
           other->slow_down_raster_scale_factor_for_debug_),
       should_attempt_to_use_distance_field_text_(
-          other->should_attempt_to_use_distance_field_text_) {}
+          other->should_attempt_to_use_distance_field_text_),
+      image_decode_controller_(other->image_decode_controller_) {}
 
 DisplayListRasterSource::~DisplayListRasterSource() {
 }
 
 void DisplayListRasterSource::PlaybackToSharedCanvas(
-    SkCanvas* canvas,
+    SkCanvas* raster_canvas,
     const gfx::Rect& canvas_rect,
     float contents_scale) const {
-  RasterCommon(canvas, NULL, canvas_rect, canvas_rect, contents_scale);
+  // TODO(vmpstr): This can be improved by plumbing whether the tile itself has
+  // discardable images. This way we would only pay for the hijack canvas if the

[enne (OOO), 2015/12/08 23:27:24]

Do you have any sense of what the expense is of the hijack canvas?

[vmpstr, 2015/12/09 23:53:41]

I don't really know how expensive it is if there are no images. The problem is
that if we aren't allowing out of raster image decodes (ie they are disabled by
a flag), then we must not have a hijack canvas, because it will cause decodes in
place for everything (since we never populated the discardable image map).

+  // tile actually needed it.
+  if (display_list_->MayHaveDiscardableImages()) {
+    SkImageInfo info = raster_canvas->imageInfo();
+    ImageHijackCanvas canvas(info.width(), info.height(),
+                             image_decode_controller_);
+    canvas.addCanvas(raster_canvas);
+
+    RasterCommon(&canvas, nullptr, canvas_rect, canvas_rect, contents_scale);
+  } else {
+    RasterCommon(raster_canvas, nullptr, canvas_rect, canvas_rect,
+                 contents_scale);
+  }
 }
 
 void DisplayListRasterSource::RasterForAnalysis(skia::AnalysisCanvas* canvas,
                                                 const gfx::Rect& canvas_rect,
                                                 float contents_scale) const {
   RasterCommon(canvas, canvas, canvas_rect, canvas_rect, contents_scale);
 }
 
 void DisplayListRasterSource::PlaybackToCanvas(
-    SkCanvas* canvas,
+    SkCanvas* raster_canvas,
     const gfx::Rect& canvas_bitmap_rect,
     const gfx::Rect& canvas_playback_rect,
     float contents_scale) const {
-  PrepareForPlaybackToCanvas(canvas, canvas_bitmap_rect, canvas_playback_rect,
-                             contents_scale);
-  RasterCommon(canvas, NULL, canvas_bitmap_rect, canvas_playback_rect,
+  PrepareForPlaybackToCanvas(raster_canvas, canvas_bitmap_rect,
+                             canvas_playback_rect, contents_scale);
+
+  SkImageInfo info = raster_canvas->imageInfo();
+  ImageHijackCanvas canvas(info.width(), info.height(),
+                           image_decode_controller_);
+  canvas.addCanvas(raster_canvas);
+  RasterCommon(&canvas, NULL, canvas_bitmap_rect, canvas_playback_rect,
                contents_scale);
 }
 
 void DisplayListRasterSource::PrepareForPlaybackToCanvas(
     SkCanvas* canvas,
     const gfx::Rect& canvas_bitmap_rect,
     const gfx::Rect& canvas_playback_rect,
     float contents_scale) const {
   // TODO(hendrikw): See if we can split this up into separate functions.
   bool partial_update = canvas_bitmap_rect != canvas_playback_rect;
@@ skipping 198 matching lines @@
   return can_use_lcd_text_;
 }
 
 scoped_refptr<DisplayListRasterSource>
 DisplayListRasterSource::CreateCloneWithoutLCDText() const {
   bool can_use_lcd_text = false;
   return scoped_refptr<DisplayListRasterSource>(
       new DisplayListRasterSource(this, can_use_lcd_text));
 }
 
+void DisplayListRasterSource::SetImageDecodeController(
+    ImageDecodeController* image_decode_controller) {
+  DCHECK(image_decode_controller);
+  // Note that although this function should only be called once, tests tend to
+  // call it several times using the same controller.
+  DCHECK(!image_decode_controller_ ||
+         image_decode_controller_ == image_decode_controller);
+  image_decode_controller_ = image_decode_controller;
+}
+
 }  // namespace cc