cc: Use SkRecord recording back-end in bleeding edge rendering mode

Start using Skia's experimental SkRecord recording back-end in the
bleeding edge rendering mode (--enable-bleeding-edge-rendering-fast-paths).
This allows us to measure the rasterization speed of this back-end in
benchmarks such as rasterize_and_record_micro.

Note that once SkRecord replaces SkPicture's internal recording back-end
this patch becomes obsolete. It is only needed during the transition
phase.

Review URL: https://codereview.chromium.org/253813002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@268507 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 126 insertions, 62 deletions

diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index 700d285..18723c8 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -124,6 +124,7 @@ bool PictureLayer::Update(ResourceUpdateQueue* queue,
                            pile_invalidation_,
                            visible_layer_rect,
                            update_source_frame_number_,
+                           RecordingMode(),
                            rendering_stats_instrumentation());
   last_updated_visible_content_rect_ = visible_content_rect();
 
@@ -142,6 +143,17 @@ void PictureLayer::SetIsMask(bool is_mask) {
   is_mask_ = is_mask;
 }
 
+Picture::RecordingMode PictureLayer::RecordingMode() const {
+  switch (layer_tree_host()->settings().recording_mode) {
+    case LayerTreeSettings::RecordNormally:
+      return Picture::RECORD_NORMALLY;
+    case LayerTreeSettings::RecordWithSkRecord:
+      return Picture::RECORD_WITH_SKRECORD;
+  }
+  NOTREACHED();
+  return Picture::RECORD_NORMALLY;
+}
+
 bool PictureLayer::SupportsLCDText() const {
   return true;
 }
diff --git a/cc/layers/picture_layer.h b/cc/layers/picture_layer.h
index dd1bbfe..740bd85 100644
--- a/cc/layers/picture_layer.h
+++ b/cc/layers/picture_layer.h
@@ -41,6 +41,8 @@ class CC_EXPORT PictureLayer : public Layer {
 
   ContentLayerClient* client() { return client_; }
 
+  Picture::RecordingMode RecordingMode() const;
+
   PicturePile* GetPicturePileForTesting() const { return pile_.get(); }
 
  protected:
diff --git a/cc/layers/picture_layer_unittest.cc b/cc/layers/picture_layer_unittest.cc
index 3edb9c8..bc52091 100644
--- a/cc/layers/picture_layer_unittest.cc
+++ b/cc/layers/picture_layer_unittest.cc
@@ -84,5 +84,20 @@ TEST(PictureLayerTest, SuitableForGpuRasterization) {
   EXPECT_FALSE(layer->IsSuitableForGpuRasterization());
 }
 
+TEST(PictureLayerTest, RecordingModes) {
+  MockContentLayerClient client;
+  scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
+
+  LayerTreeSettings settings;
+  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(settings);
+  host->SetRootLayer(layer);
+  EXPECT_EQ(Picture::RECORD_NORMALLY, layer->RecordingMode());
+
+  settings.recording_mode = LayerTreeSettings::RecordWithSkRecord;
+  host = FakeLayerTreeHost::Create(settings);
+  host->SetRootLayer(layer);
+  EXPECT_EQ(Picture::RECORD_WITH_SKRECORD, layer->RecordingMode());
+}
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/resources/picture.cc b/cc/resources/picture.cc
index d9b45df..7147a15 100644
--- a/cc/resources/picture.cc
+++ b/cc/resources/picture.cc
@@ -391,7 +391,8 @@ int Picture::Raster(
     SkDrawPictureCallback* callback,
     const Region& negated_content_region,
     float contents_scale) {
-  DCHECK(raster_thread_checker_.CalledOnValidThread());
+  if (!playback_)
+    DCHECK(raster_thread_checker_.CalledOnValidThread());
   TRACE_EVENT_BEGIN1(
       "cc",
       "Picture::Raster",
@@ -422,7 +423,8 @@ int Picture::Raster(
 }
 
 void Picture::Replay(SkCanvas* canvas) {
-  DCHECK(raster_thread_checker_.CalledOnValidThread());
+  if (!playback_)
+    DCHECK(raster_thread_checker_.CalledOnValidThread());
   TRACE_EVENT_BEGIN0("cc", "Picture::Replay");
   DCHECK(picture_);
 
@@ -440,8 +442,21 @@ void Picture::Replay(SkCanvas* canvas) {
 scoped_ptr<base::Value> Picture::AsValue() const {
   SkDynamicMemoryWStream stream;
 
-  // Serialize the picture.
-  picture_->serialize(&stream, &EncodeBitmap);
+  if (playback_) {
+    // SkPlayback can't serialize itself, so re-record into an SkPicture.
+    SkPictureRecorder recorder;
+    skia::RefPtr<SkCanvas> canvas(skia::SharePtr(recorder.beginRecording(
+        layer_rect_.width(),
+        layer_rect_.height(),
+        NULL,  // Default (no) bounding-box hierarchy is fastest.
+        SkPicture::kUsePathBoundsForClip_RecordingFlag)));
+    playback_->draw(canvas.get());
+    skia::RefPtr<SkPicture> picture(skia::AdoptRef(recorder.endRecording()));
+    picture->serialize(&stream, &EncodeBitmap);
+  } else {
+    // Serialize the picture.
+    picture_->serialize(&stream, &EncodeBitmap);
+  }
 
   // Encode the picture as base64.
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
diff --git a/cc/resources/picture.h b/cc/resources/picture.h
index 4761ca6..78833d1 100644
--- a/cc/resources/picture.h
+++ b/cc/resources/picture.h
@@ -75,8 +75,10 @@ class CC_EXPORT Picture
 
   bool IsSuitableForGpuRasterization() const;
 
-  // Apply this scale and raster the negated region into the canvas. See comment
-  // in PicturePileImpl::RasterCommon for explanation on negated content region.
+  // Apply this scale and raster the negated region into the canvas.
+  // |negated_content_region| specifies the region to be clipped out of the
+  // raster operation, i.e., the parts of the canvas which will not get drawn
+  // to.
   int Raster(SkCanvas* canvas,
              SkDrawPictureCallback* callback,
              const Region& negated_content_region,
diff --git a/cc/resources/picture_pile.cc b/cc/resources/picture_pile.cc
index 6637e4d..27c58a1 100644
--- a/cc/resources/picture_pile.cc
+++ b/cc/resources/picture_pile.cc
@@ -153,6 +153,7 @@ bool PicturePile::Update(ContentLayerClient* painter,
                          const Region& invalidation,
                          const gfx::Rect& visible_layer_rect,
                          int frame_number,
+                         Picture::RecordingMode recording_mode,
                          RenderingStatsInstrumentation* stats_instrumentation) {
   background_color_ = background_color;
   contents_opaque_ = contents_opaque;
@@ -243,7 +244,7 @@ bool PicturePile::Update(ContentLayerClient* painter,
                                   tile_grid_info_,
                                   gather_pixel_refs,
                                   num_raster_threads,
-                                  Picture::RECORD_NORMALLY);
+                                  recording_mode);
         // Note the '&&' with previous is-suitable state.
         // This means that once a picture-pile becomes unsuitable for gpu
         // rasterization due to some content, it will continue to be unsuitable
diff --git a/cc/resources/picture_pile.h b/cc/resources/picture_pile.h
index dbc3966..415bbdfe 100644
--- a/cc/resources/picture_pile.h
+++ b/cc/resources/picture_pile.h
@@ -27,6 +27,7 @@ class CC_EXPORT PicturePile : public PicturePileBase {
               const Region& invalidation,
               const gfx::Rect& visible_layer_rect,
               int frame_number,
+              Picture::RecordingMode recording_mode,
               RenderingStatsInstrumentation* stats_instrumentation);
 
   void set_slow_down_raster_scale_factor(int factor) {
diff --git a/cc/resources/picture_pile_unittest.cc b/cc/resources/picture_pile_unittest.cc
index 04b4c33..0387863 100644
--- a/cc/resources/picture_pile_unittest.cc
+++ b/cc/resources/picture_pile_unittest.cc
@@ -60,6 +60,7 @@ class PicturePileTest : public testing::Test {
                          invalidation,
                          visible_layer_rect,
                          frame_number_,
+                         Picture::RECORD_NORMALLY,
                          &stats_instrumentation_);
   }
 
diff --git a/cc/resources/picture_unittest.cc b/cc/resources/picture_unittest.cc
index 61b048a..1367c5f 100644
--- a/cc/resources/picture_unittest.cc
+++ b/cc/resources/picture_unittest.cc
@@ -43,68 +43,75 @@ TEST(PictureTest, AsBase64String) {
   tmp.reset(new base::StringValue("abc!@#$%"));
   scoped_refptr<Picture> invalid_picture =
       Picture::CreateFromValue(tmp.get());
-  EXPECT_TRUE(!invalid_picture.get());
+  EXPECT_FALSE(invalid_picture.get());
+
+  Picture::RecordingMode kRecordingModes[] = {Picture::RECORD_NORMALLY,
+                                              Picture::RECORD_WITH_SKRECORD};
 
   // Single full-size rect picture.
   content_layer_client.add_draw_rect(layer_rect, red_paint);
-  scoped_refptr<Picture> one_rect_picture =
-      Picture::Create(layer_rect,
-                      &content_layer_client,
-                      tile_grid_info,
-                      false,
-                      0,
-                      Picture::RECORD_NORMALLY);
-  scoped_ptr<base::Value> serialized_one_rect(
-      one_rect_picture->AsValue());
-
-  // Reconstruct the picture.
-  scoped_refptr<Picture> one_rect_picture_check =
-      Picture::CreateFromValue(serialized_one_rect.get());
-  EXPECT_TRUE(!!one_rect_picture_check.get());
 
-  // Check for equivalence.
-  unsigned char one_rect_buffer[4 * 100 * 100] = {0};
-  DrawPicture(one_rect_buffer, layer_rect, one_rect_picture);
-  unsigned char one_rect_buffer_check[4 * 100 * 100] = {0};
-  DrawPicture(one_rect_buffer_check, layer_rect, one_rect_picture_check);
-
-  EXPECT_EQ(one_rect_picture->LayerRect(),
-            one_rect_picture_check->LayerRect());
-  EXPECT_EQ(one_rect_picture->OpaqueRect(),
-            one_rect_picture_check->OpaqueRect());
-  EXPECT_TRUE(
-      memcmp(one_rect_buffer, one_rect_buffer_check, 4 * 100 * 100) == 0);
+  for (size_t i = 0; i < arraysize(kRecordingModes); ++i) {
+    scoped_refptr<Picture> one_rect_picture =
+        Picture::Create(layer_rect,
+                        &content_layer_client,
+                        tile_grid_info,
+                        false,
+                        0,
+                        kRecordingModes[i]);
+    scoped_ptr<base::Value> serialized_one_rect(one_rect_picture->AsValue());
+
+    // Reconstruct the picture.
+    scoped_refptr<Picture> one_rect_picture_check =
+        Picture::CreateFromValue(serialized_one_rect.get());
+    EXPECT_TRUE(!!one_rect_picture_check.get());
+
+    // Check for equivalence.
+    unsigned char one_rect_buffer[4 * 100 * 100] = {0};
+    DrawPicture(one_rect_buffer, layer_rect, one_rect_picture);
+    unsigned char one_rect_buffer_check[4 * 100 * 100] = {0};
+    DrawPicture(one_rect_buffer_check, layer_rect, one_rect_picture_check);
+
+    EXPECT_EQ(one_rect_picture->LayerRect(),
+              one_rect_picture_check->LayerRect());
+    EXPECT_EQ(one_rect_picture->OpaqueRect(),
+              one_rect_picture_check->OpaqueRect());
+    EXPECT_TRUE(memcmp(one_rect_buffer, one_rect_buffer_check, 4 * 100 * 100) ==
+                0);
+  }
 
   // Two rect picture.
   content_layer_client.add_draw_rect(gfx::Rect(25, 25, 50, 50), green_paint);
-  scoped_refptr<Picture> two_rect_picture =
-      Picture::Create(layer_rect,
-                      &content_layer_client,
-                      tile_grid_info,
-                      false,
-                      0,
-                      Picture::RECORD_NORMALLY);
 
-  scoped_ptr<base::Value> serialized_two_rect(
-      two_rect_picture->AsValue());
-
-  // Reconstruct the picture.
-  scoped_refptr<Picture> two_rect_picture_check =
-      Picture::CreateFromValue(serialized_two_rect.get());
-  EXPECT_TRUE(!!two_rect_picture_check.get());
-
-  // Check for equivalence.
-  unsigned char two_rect_buffer[4 * 100 * 100] = {0};
-  DrawPicture(two_rect_buffer, layer_rect, two_rect_picture);
-  unsigned char two_rect_buffer_check[4 * 100 * 100] = {0};
-  DrawPicture(two_rect_buffer_check, layer_rect, two_rect_picture_check);
-
-  EXPECT_EQ(two_rect_picture->LayerRect(),
-            two_rect_picture_check->LayerRect());
-  EXPECT_EQ(two_rect_picture->OpaqueRect(),
-            two_rect_picture_check->OpaqueRect());
-  EXPECT_TRUE(
-      memcmp(two_rect_buffer, two_rect_buffer_check, 4 * 100 * 100) == 0);
+  for (size_t i = 0; i < arraysize(kRecordingModes); ++i) {
+    scoped_refptr<Picture> two_rect_picture =
+        Picture::Create(layer_rect,
+                        &content_layer_client,
+                        tile_grid_info,
+                        false,
+                        0,
+                        Picture::RECORD_NORMALLY);
+
+    scoped_ptr<base::Value> serialized_two_rect(two_rect_picture->AsValue());
+
+    // Reconstruct the picture.
+    scoped_refptr<Picture> two_rect_picture_check =
+        Picture::CreateFromValue(serialized_two_rect.get());
+    EXPECT_TRUE(!!two_rect_picture_check.get());
+
+    // Check for equivalence.
+    unsigned char two_rect_buffer[4 * 100 * 100] = {0};
+    DrawPicture(two_rect_buffer, layer_rect, two_rect_picture);
+    unsigned char two_rect_buffer_check[4 * 100 * 100] = {0};
+    DrawPicture(two_rect_buffer_check, layer_rect, two_rect_picture_check);
+
+    EXPECT_EQ(two_rect_picture->LayerRect(),
+              two_rect_picture_check->LayerRect());
+    EXPECT_EQ(two_rect_picture->OpaqueRect(),
+              two_rect_picture_check->OpaqueRect());
+    EXPECT_TRUE(memcmp(two_rect_buffer, two_rect_buffer_check, 4 * 100 * 100) ==
+                0);
+  }
 }
 
 TEST(PictureTest, PixelRefIterator) {
diff --git a/cc/test/skia_common.cc b/cc/test/skia_common.cc
index 7d1c3b8..d91e707 100644
--- a/cc/test/skia_common.cc
+++ b/cc/test/skia_common.cc
@@ -21,7 +21,9 @@ void DrawPicture(unsigned char* buffer,
   bitmap.installPixels(info, buffer, info.minRowBytes());
   SkCanvas canvas(bitmap);
   canvas.clipRect(gfx::RectToSkRect(layer_rect));
-  picture->Raster(&canvas, NULL, layer_rect, 1.0f);
+  // We're drawing the entire canvas, so the negated content region is empty.
+  gfx::Rect negated_content_region;
+  picture->Raster(&canvas, NULL, negated_content_region, 1.0f);
 }
 
 void CreateBitmap(const gfx::Size& size, const char* uri, SkBitmap* bitmap) {
diff --git a/cc/trees/layer_tree_settings.cc b/cc/trees/layer_tree_settings.cc
index 5a6f51f..5360bd4 100644
--- a/cc/trees/layer_tree_settings.cc
+++ b/cc/trees/layer_tree_settings.cc
@@ -28,6 +28,7 @@ LayerTreeSettings::LayerTreeSettings()
       should_clear_root_render_pass(true),
       gpu_rasterization_enabled(false),
       gpu_rasterization_forced(false),
+      recording_mode(RecordNormally),
       create_low_res_tiling(true),
       scrollbar_animator(NoAnimator),
       scrollbar_fade_delay_ms(0),
diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
index fcb9a40..ad3ee6f 100644
--- a/cc/trees/layer_tree_settings.h
+++ b/cc/trees/layer_tree_settings.h
@@ -33,6 +33,11 @@ class CC_EXPORT LayerTreeSettings {
   bool should_clear_root_render_pass;
   bool gpu_rasterization_enabled;
   bool gpu_rasterization_forced;
+  enum RecordingMode {
+    RecordNormally,
+    RecordWithSkRecord,
+  };
+  RecordingMode recording_mode;
   bool create_low_res_tiling;
 
   enum ScrollbarAnimator {