cc: Remove the base RasterSource

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/trace_event/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/playback/display_item_list.h"
-#include "cc/playback/raster_source_helper.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 scoped_refptr<DisplayListRasterSource>
 DisplayListRasterSource::CreateFromDisplayListRecordingSource(
     const DisplayListRecordingSource* other,
@@ skipping 51 matching lines @@
                                                 const gfx::Rect& canvas_rect,
                                                 float contents_scale) const {
   RasterCommon(canvas, canvas, canvas_rect, canvas_rect, contents_scale);
 }
 
 void DisplayListRasterSource::PlaybackToCanvas(
     SkCanvas* canvas,
     const gfx::Rect& canvas_bitmap_rect,
     const gfx::Rect& canvas_playback_rect,
     float contents_scale) const {
-  RasterSourceHelper::PrepareForPlaybackToCanvas(
-      canvas, canvas_bitmap_rect, canvas_playback_rect, gfx::Rect(size_),
-      contents_scale, background_color_, clear_canvas_with_debug_color_,
-      requires_clear_);
+  bool partial_update = canvas_bitmap_rect != canvas_playback_rect;

[vmpstr, 2015/10/15 17:33:32]

Can you put this code in a helper function?

[hendrikw, 2015/10/15 17:43:18]

Then we'd have one function with 80 lines (instead of 82), and a second function
with 2 lines.  If there were a clear way to split this down the middle
somewhere, I'd say yes, but in this case, I don't think a helper function will
add much clarity to this.

[vmpstr, 2015/10/15 17:55:26]

Oh, I don't mean that this function is too long. I meant more of a logical
split. For instance, seeing the difference between PlaybackToCanvas and
PlaybackToSharedCanvas is a lot easier if you just see one extra call. And based
on the name of the function, you can assume that it doesn't do anything like
translate the canvas (without restoring). I think it's still useful.

+
+  if (!partial_update)
+    canvas->discard();
+  if (clear_canvas_with_debug_color_) {
+    // Any non-painted areas in the content bounds will be left in this color.
+    if (!partial_update) {
+      canvas->clear(DebugColors::NonPaintedFillColor());
+    } else {
+      canvas->save();
+      canvas->clipRect(gfx::RectToSkRect(
+          canvas_playback_rect - canvas_bitmap_rect.OffsetFromOrigin()));
+      canvas->drawColor(DebugColors::NonPaintedFillColor());
+      canvas->restore();
+    }
+  }
+
+  // If this raster source has opaque contents, it is guaranteeing that it will
+  // draw an opaque rect the size of the layer.  If it is not, then we must
+  // clear this canvas ourselves.
+  if (requires_clear_) {
+    TRACE_EVENT_INSTANT0("cc", "SkCanvas::clear", TRACE_EVENT_SCOPE_THREAD);
+    // Clearing is about ~4x faster than drawing a rect even if the content
+    // isn't covering a majority of the canvas.
+    if (!partial_update) {
+      canvas->clear(SK_ColorTRANSPARENT);
+    } else {
+      canvas->save();
+      canvas->clipRect(gfx::RectToSkRect(
+          canvas_playback_rect - canvas_bitmap_rect.OffsetFromOrigin()));
+      canvas->drawColor(SK_ColorTRANSPARENT, SkXfermode::kClear_Mode);
+      canvas->restore();
+    }
+  } else {
+    // Even if completely covered, for rasterizations that touch the edge of the
+    // layer, we also need to raster the background color underneath the last
+    // texel (since the recording won't cover it) and outside the last texel
+    // (due to linear filtering when using this texture).
+    gfx::Rect content_rect =
+        gfx::ScaleToEnclosingRect(gfx::Rect(size_), contents_scale);
+
+    // The final texel of content may only be partially covered by a
+    // rasterization; this rect represents the content rect that is fully
+    // covered by content.
+    gfx::Rect deflated_content_rect = content_rect;
+    deflated_content_rect.Inset(0, 0, 1, 1);
+    deflated_content_rect.Intersect(canvas_playback_rect);
+    if (!deflated_content_rect.Contains(canvas_playback_rect)) {
+      if (clear_canvas_with_debug_color_) {
+        // Any non-painted areas outside of the content bounds are left in
+        // this color.  If this is seen then it means that cc neglected to
+        // rerasterize a tile that used to intersect with the content rect
+        // after the content bounds grew.
+        canvas->save();
+        canvas->translate(-canvas_bitmap_rect.x(), -canvas_bitmap_rect.y());
+        canvas->clipRect(gfx::RectToSkRect(content_rect),
+                         SkRegion::kDifference_Op);
+        canvas->drawColor(DebugColors::MissingResizeInvalidations(),
+                          SkXfermode::kSrc_Mode);
+        canvas->restore();
+      }
+
+      // Drawing at most 2 x 2 x (canvas width + canvas height) texels is 2-3X
+      // faster than clearing, so special case this.
+      canvas->save();
+      canvas->translate(-canvas_bitmap_rect.x(), -canvas_bitmap_rect.y());
+      gfx::Rect inflated_content_rect = content_rect;
+      // Only clear edges that will be inside the canvas_playback_rect, else we
+      // clear things that are still valid from a previous raster.
+      inflated_content_rect.Inset(0, 0, -1, -1);
+      inflated_content_rect.Intersect(canvas_playback_rect);
+      canvas->clipRect(gfx::RectToSkRect(inflated_content_rect),
+                       SkRegion::kReplace_Op);
+      canvas->clipRect(gfx::RectToSkRect(deflated_content_rect),
+                       SkRegion::kDifference_Op);
+      canvas->drawColor(background_color_, SkXfermode::kSrc_Mode);
+      canvas->restore();
+    }
+  }
 
   RasterCommon(canvas, NULL, canvas_bitmap_rect, canvas_playback_rect,
                contents_scale);
 }
 
 void DisplayListRasterSource::RasterCommon(
     SkCanvas* canvas,
     SkPicture::AbortCallback* callback,
     const gfx::Rect& canvas_bitmap_rect,
     const gfx::Rect& canvas_playback_rect,
@@ skipping 33 matching lines @@
 size_t DisplayListRasterSource::GetPictureMemoryUsage() const {
   if (!display_list_)
     return 0;
   return display_list_->ApproximateMemoryUsage() +
          painter_reported_memory_usage_;
 }
 
 void DisplayListRasterSource::PerformSolidColorAnalysis(
     const gfx::Rect& content_rect,
     float contents_scale,
-    RasterSource::SolidColorAnalysis* analysis) const {
+    DisplayListRasterSource::SolidColorAnalysis* analysis) const {
   DCHECK(analysis);
   TRACE_EVENT0("cc", "DisplayListRasterSource::PerformSolidColorAnalysis");
 
   gfx::Rect layer_rect =
       gfx::ScaleToEnclosingRect(content_rect, 1.0f / contents_scale);
 
   layer_rect.Intersect(gfx::Rect(size_));
   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
   RasterForAnalysis(&canvas, layer_rect, 1.0f);
   analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
@@ skipping 51 matching lines @@
 
 void DisplayListRasterSource::DidBeginTracing() {
   if (display_list_.get())
     display_list_->EmitTraceSnapshot();
 }
 
 bool DisplayListRasterSource::CanUseLCDText() const {
   return can_use_lcd_text_;
 }
 
-scoped_refptr<RasterSource> DisplayListRasterSource::CreateCloneWithoutLCDText()
-    const {
+scoped_refptr<DisplayListRasterSource>
+DisplayListRasterSource::CreateCloneWithoutLCDText() const {
   bool can_use_lcd_text = false;
-  return scoped_refptr<RasterSource>(
+  return scoped_refptr<DisplayListRasterSource>(
       new DisplayListRasterSource(this, can_use_lcd_text));
 }
 
 }  // namespace cc