cc: Add color space to image decode caches

cc/raster/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/raster/raster_source.h"
 
 #include <stddef.h>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 43 matching lines @@
       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_),
       image_decode_cache_(other->image_decode_cache_) {}
 
 RasterSource::~RasterSource() {}
 
 void RasterSource::PlaybackToCanvas(SkCanvas* raster_canvas,
-                                    const gfx::ColorSpace& canvas_color_space,
+                                    const gfx::ColorSpace& target_color_space,
                                     const gfx::Rect& canvas_bitmap_rect,
                                     const gfx::Rect& canvas_playback_rect,
                                     float raster_scale,
                                     const PlaybackSettings& settings) const {
   SkIRect raster_bounds = gfx::RectToSkIRect(canvas_bitmap_rect);
   if (!canvas_playback_rect.IsEmpty() &&
       !raster_bounds.intersect(gfx::RectToSkIRect(canvas_playback_rect)))
     return;
   // Treat all subnormal values as zero for performance.
   ScopedSubnormalFloatDisabler disabler;
 
   raster_canvas->save();
   raster_canvas->translate(-canvas_bitmap_rect.x(), -canvas_bitmap_rect.y());
   raster_canvas->clipRect(SkRect::MakeFromIRect(raster_bounds));
   raster_canvas->scale(raster_scale, raster_scale);
-  PlaybackToCanvas(raster_canvas, canvas_color_space, settings);
+  PlaybackToCanvas(raster_canvas, target_color_space, settings);
   raster_canvas->restore();
 }
 
-void RasterSource::PlaybackToCanvas(SkCanvas* raster_canvas,
-                                    const gfx::ColorSpace& canvas_color_space,
+void RasterSource::PlaybackToCanvas(SkCanvas* input_canvas,
+                                    const gfx::ColorSpace& target_color_space,
                                     const PlaybackSettings& settings) const {
+  SkCanvas* raster_canvas = input_canvas;
+  std::unique_ptr<SkCanvas> color_transform_canvas;
+  if (target_color_space.IsValid()) {
+    color_transform_canvas = SkCreateColorSpaceXformCanvas(
+        input_canvas, target_color_space.ToSkColorSpace());
+    raster_canvas = color_transform_canvas.get();
+  }
+
   if (!settings.playback_to_shared_canvas)
     PrepareForPlaybackToCanvas(raster_canvas);
 
   if (settings.skip_images) {
     SkipImageCanvas canvas(raster_canvas);
-    RasterCommon(&canvas, canvas_color_space, nullptr);
+    RasterCommon(&canvas, nullptr);
   } else if (settings.use_image_hijack_canvas) {
     const SkImageInfo& info = raster_canvas->imageInfo();
     ImageHijackCanvas canvas(info.width(), info.height(), image_decode_cache_,
-                             &settings.images_to_skip);
+                             &settings.images_to_skip, target_color_space);

[vmpstr, 2017/04/04 01:16:43]

ImageHijackCanvas intercepts some calls to things like drawImage, grabs the
needed image out of the cache, and then passes that to the underlying canvas'
drawImage. I assume that works correctly here? That is, we would be passing a
color converted image to the canvas created on line 90. Are SkImages already
tagged with the right color space at that point?

(I'm trying to avoid double conversion)

[ccameron, 2017/04/04 06:41:10]

Yeah, the input SkImage will be in "image color space" (usually sRGB, but could
be anything, in principle), and then the ImageHijackCanvas will replace it with
an SkImage that is in target_color_space. The SkColorSpaceXformCanvas will see
"oh, this image is already in my target_color_space, I don't need to do anything
here".

     // Before adding the canvas, make sure that the ImageHijackCanvas is aware
     // of the current transform and clip, which may affect the clip bounds.
     // Since we query the clip bounds of the current canvas to get the list of
     // draw commands to process, this is important to produce correct content.
     canvas.clipRect(
         SkRect::MakeFromIRect(raster_canvas->getDeviceClipBounds()));
     canvas.setMatrix(raster_canvas->getTotalMatrix());
     canvas.addCanvas(raster_canvas);
 
-    RasterCommon(&canvas, canvas_color_space, nullptr);
+    RasterCommon(&canvas, nullptr);
   } else {
-    RasterCommon(raster_canvas, canvas_color_space, nullptr);
+    RasterCommon(raster_canvas, nullptr);
   }
 }
 
 namespace {
 
 bool CanvasIsUnclipped(const SkCanvas* canvas) {
   if (!canvas->isClipRect())
     return false;
 
   SkIRect bounds;
@@ skipping 72 matching lines @@
   canvas->save();
   // Use clipRegion to bypass CTM because the rects are device rects.
   SkRegion interest_region;
   interest_region.setRect(interest_rect);
   interest_region.op(opaque_rect, SkRegion::kDifference_Op);
   canvas->clipRegion(interest_region);
   canvas->clear(background_color_);
   canvas->restore();
 }
 
-void RasterSource::RasterCommon(SkCanvas* input_canvas,
-                                const gfx::ColorSpace& target_color_space,
+void RasterSource::RasterCommon(SkCanvas* raster_canvas,
                                 SkPicture::AbortCallback* callback) const {
-  SkCanvas* raster_canvas = input_canvas;
-  std::unique_ptr<SkCanvas> color_transform_canvas;
-  if (target_color_space.IsValid()) {
-    color_transform_canvas = SkCreateColorSpaceXformCanvas(
-        input_canvas, target_color_space.ToSkColorSpace());
-    raster_canvas = color_transform_canvas.get();
-  }
   DCHECK(display_list_.get());
   int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
   for (int i = 0; i < repeat_count; ++i)
     display_list_->Raster(raster_canvas, callback);
 }
 
 sk_sp<SkPicture> RasterSource::GetFlattenedPicture() {
   TRACE_EVENT0("cc", "RasterSource::GetFlattenedPicture");
 
   SkPictureRecorder recorder;
   SkCanvas* canvas = recorder.beginRecording(size_.width(), size_.height());
   if (!size_.IsEmpty()) {
     PrepareForPlaybackToCanvas(canvas);
-    // No target color space should be set for generating an SkPicture.
-    RasterCommon(canvas, gfx::ColorSpace(), nullptr);
+    RasterCommon(canvas, nullptr);
   }
 
   return recorder.finishRecordingAsPicture();
 }
 
 size_t RasterSource::GetMemoryUsage() const {
   if (!display_list_)
     return 0;
   return display_list_->ApproximateMemoryUsage() +
          painter_reported_memory_usage_;
 }
 
 bool RasterSource::PerformSolidColorAnalysis(const gfx::Rect& content_rect,
                                              float contents_scale,
                                              SkColor* color) const {
   TRACE_EVENT0("cc", "RasterSource::PerformSolidColorAnalysis");
 
   gfx::Rect layer_rect =
       gfx::ScaleToEnclosingRect(content_rect, 1.f / contents_scale);
 
   layer_rect.Intersect(gfx::Rect(size_));
   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
   canvas.translate(-layer_rect.x(), -layer_rect.y());
-  // No target color space should be set for solid color analysis (the
-  // resulting solid color will be known to be sRGB).
-  RasterCommon(&canvas, gfx::ColorSpace(), &canvas);
+  // Note that because no color conversion is applied to solid color analysis,
+  // the resulting solid color will be known to be sRGB.
+  RasterCommon(&canvas, &canvas);
   return canvas.GetColorIfSolid(color);
 }
 
 void RasterSource::GetDiscardableImagesInRect(
     const gfx::Rect& layer_rect,
     float contents_scale,
+    const gfx::ColorSpace& target_color_space,
     std::vector<DrawImage>* images) const {
   DCHECK_EQ(0u, images->size());
-  display_list_->GetDiscardableImagesInRect(layer_rect, contents_scale, images);
+  display_list_->GetDiscardableImagesInRect(layer_rect, contents_scale,
+                                            target_color_space, images);
 }
 
 gfx::Rect RasterSource::GetRectForImage(ImageId image_id) const {
   if (!display_list_)
     return gfx::Rect();
   return display_list_->GetRectForImage(image_id);
 }
 
 bool RasterSource::CoversRect(const gfx::Rect& layer_rect) const {
   if (size_.IsEmpty())
@@ skipping 49 matching lines @@
       use_image_hijack_canvas(true) {}
 
 RasterSource::PlaybackSettings::PlaybackSettings(const PlaybackSettings&) =
     default;
 
 RasterSource::PlaybackSettings::PlaybackSettings(PlaybackSettings&&) = default;
 
 RasterSource::PlaybackSettings::~PlaybackSettings() = default;
 
 }  // namespace cc