Implements core logic for Pixel Canvas

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 62 matching lines @@
       !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->translate(raster_transform.translation().x(),
                            raster_transform.translation().y());
-  raster_canvas->scale(raster_transform.scale(), raster_transform.scale());
+  if (!display_list_->pixel_canvas_enabled())

[danakj, 2017/06/27 16:28:36]

I don't think this is okay, this assumes that the transform seen at painting is
always the same as at raster, but if a scale is applied in the compositor then
it doesn't have to be.

This also feels very weird WRT layering, in that DisplayItemList is knowing
things about ui painting things and this seems problematic to me.

[malaykeshav, 2017/07/07 22:57:09]

This has been updated after offline discussion.
The value is now plumbed to the raster source as a recording_scale_factor. This
component is then removed from the raster transform.

+    raster_canvas->scale(raster_transform.scale(), raster_transform.scale());
   PlaybackToCanvas(raster_canvas, target_color_space, settings);
   raster_canvas->restore();
 }
 
 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()) {
@@ skipping 136 matching lines @@
 
   return recorder.finishRecordingAsPicture();
 }
 
 size_t RasterSource::GetMemoryUsage() const {
   if (!display_list_)
     return 0;
   return display_list_->BytesUsed() + painter_reported_memory_usage_;
 }
 
-bool RasterSource::PerformSolidColorAnalysis(const gfx::Rect& content_rect,
-                                             float contents_scale,
-                                             SkColor* color) const {
+bool RasterSource::PerformSolidColorAnalysis(
+    gfx::Rect content_rect,
+    const gfx::AxisTransform2d& raster_transform,
+    SkColor* color) const {
   TRACE_EVENT0("cc", "RasterSource::PerformSolidColorAnalysis");
+  if (display_list_->pixel_canvas_enabled()) {
+    content_rect.Intersect(
+        gfx::ScaleToEnclosingRect(gfx::Rect(size_), raster_transform.scale()));
+  } else {
+    content_rect = gfx::ToEnclosingRect(
+        raster_transform.InverseMapRect(gfx::RectF(content_rect)));
+    content_rect.Intersect(gfx::Rect(size_));
+  }
+  skia::AnalysisCanvas canvas(content_rect.width(), content_rect.height());
+  canvas.translate(-content_rect.x(), -content_rect.y());
 
-  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());
   // 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,
@@ skipping 63 matching lines @@
       use_image_hijack_canvas(true) {}
 
 RasterSource::PlaybackSettings::PlaybackSettings(const PlaybackSettings&) =
     default;
 
 RasterSource::PlaybackSettings::PlaybackSettings(PlaybackSettings&&) = default;
 
 RasterSource::PlaybackSettings::~PlaybackSettings() = default;
 
 }  // namespace cc