Hack SkRecord in as an alternate recording mode in cc/resources/picture.

cc/resources/picture.cc

 // Copyright 2012 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/resources/picture.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 174 matching lines @@
     pixel_refs_(pixel_refs),
     cell_size_(layer_rect.size()) {
 }
 
 Picture::~Picture() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
     TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::Picture", this);
 }
 
 Picture* Picture::GetCloneForDrawingOnThread(unsigned thread_index) {
+  // We don't need clones to draw from multiple threads with SkRecord.
+  if (playback_) {
+    return this;
+  }
+
   // SkPicture is not thread-safe to rasterize with, this returns a clone
   // to rasterize with on a specific thread.
   CHECK_GE(clones_.size(), thread_index);
   return thread_index == clones_.size() ? this : clones_[thread_index].get();
 }
 
 bool Picture::IsSuitableForGpuRasterization() const {
   DCHECK(picture_);
 
   // TODO(alokp): SkPicture::suitableForGpuRasterization needs a GrContext.
   // Ideally this GrContext should be the same as that for rasterizing this
   // picture. But we are on the main thread while the rasterization context
   // may be on the compositor or raster thread.
   // SkPicture::suitableForGpuRasterization is not implemented yet.
   // Pass a NULL context for now and discuss with skia folks if the context
   // is really needed.
   return picture_->suitableForGpuRasterization(NULL);
 }
 
 void Picture::CloneForDrawing(int num_threads) {
   TRACE_EVENT1("cc", "Picture::CloneForDrawing", "num_threads", num_threads);
 
+  // We don't need clones to draw from multiple threads with SkRecord.
+  if (playback_) {
+    return;
+  }
+
   DCHECK(picture_);
   DCHECK(clones_.empty());
 
   // We can re-use this picture for one raster worker thread.
   raster_thread_checker_.DetachFromThread();
 
   if (num_threads > 1) {
     scoped_ptr<SkPicture[]> clones(new SkPicture[num_threads - 1]);
     picture_->clone(&clones[0], num_threads - 1);
 
@@ skipping 20 matching lines @@
                AsTraceableRecordData(),
                "recording_mode",
                recording_mode);
 
   DCHECK(!picture_);
   DCHECK(!tile_grid_info.fTileInterval.isEmpty());
 
   SkTileGridFactory factory(tile_grid_info);
   SkPictureRecorder recorder;
 
+  scoped_ptr<EXPERIMENTAL::SkRecording> recording;
+
   skia::RefPtr<SkCanvas> canvas;
   canvas = skia::SharePtr(
       recorder.beginRecording(layer_rect_.width(),
                               layer_rect_.height(),
                               &factory,
                               SkPicture::kUsePathBoundsForClip_RecordingFlag));
 
   switch (recording_mode) {
     case RECORD_NORMALLY:
       // Already setup for normal recording
       break;
     case RECORD_WITH_SK_NULL_CANVAS:
       canvas = skia::AdoptRef(SkCreateNullCanvas());
       break;
     case RECORD_WITH_PAINTING_DISABLED:
       // Blink's GraphicsContext will disable painting when given a NULL
       // canvas.
       canvas.clear();
       break;
+    case RECORD_WITH_SKRECORD:
+      recording.reset(new EXPERIMENTAL::SkRecording(layer_rect_.width(),
+                                                    layer_rect_.height()));
+      canvas = skia::SharePtr(recording->canvas());
+      break;
     default:
       NOTREACHED();
   }
 
   if (canvas) {
     canvas->save();
     canvas->translate(SkFloatToScalar(-layer_rect_.x()),
                       SkFloatToScalar(-layer_rect_.y()));
 
     SkRect layer_skrect = SkRect::MakeXYWH(layer_rect_.x(),
                                            layer_rect_.y(),
                                            layer_rect_.width(),
                                            layer_rect_.height());
     canvas->clipRect(layer_skrect);
   }
 
   gfx::RectF opaque_layer_rect;
   painter->PaintContents(canvas.get(), layer_rect_, &opaque_layer_rect);
 
   if (canvas)
     canvas->restore();
   picture_ = skia::AdoptRef(recorder.endRecording());
   DCHECK(picture_);
 
+  if (recording) {
+    // SkRecording requires it's the only one holding onto canvas before we
+    // may call releasePlayback().  (This helps enforce thread-safety.)
+    canvas.clear();
+    playback_.reset(recording->releasePlayback());
+  }
+
   opaque_rect_ = gfx::ToEnclosedRect(opaque_layer_rect);
 
   EmitTraceSnapshot();
 }
 
 void Picture::GatherPixelRefs(
     const SkTileGridFactory::TileGridInfo& tile_grid_info) {
   TRACE_EVENT2("cc", "Picture::GatherPixelRefs",
                "width", layer_rect_.width(),
                "height", layer_rect_.height());
@@ skipping 62 matching lines @@
 
   DCHECK(picture_);
 
   canvas->save();
 
   for (Region::Iterator it(negated_content_region); it.has_rect(); it.next())
     canvas->clipRect(gfx::RectToSkRect(it.rect()), SkRegion::kDifference_Op);
 
   canvas->scale(contents_scale, contents_scale);
   canvas->translate(layer_rect_.x(), layer_rect_.y());
-  picture_->draw(canvas, callback);
+  if (playback_) {
+    playback_->draw(canvas);
+  } else {
+    picture_->draw(canvas, callback);
+  }
   SkIRect bounds;
   canvas->getClipDeviceBounds(&bounds);
   canvas->restore();
   TRACE_EVENT_END1(
       "cc", "Picture::Raster",
       "num_pixels_rasterized", bounds.width() * bounds.height());
   return bounds.width() * bounds.height();
 }
 
 void Picture::Replay(SkCanvas* canvas) {
   DCHECK(raster_thread_checker_.CalledOnValidThread());
   TRACE_EVENT_BEGIN0("cc", "Picture::Replay");
   DCHECK(picture_);
 
-  picture_->draw(canvas);
+  if (playback_) {
+    playback_->draw(canvas);
+  } else {
+    picture_->draw(canvas);
+  }
   SkIRect bounds;
   canvas->getClipDeviceBounds(&bounds);
   TRACE_EVENT_END1("cc", "Picture::Replay",
                    "num_pixels_replayed", bounds.width() * bounds.height());
 }
 
 scoped_ptr<base::Value> Picture::AsValue() const {
   SkDynamicMemoryWStream stream;
 
   // Serialize the picture.
@@ skipping 137 matching lines @@
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
     Picture::AsTraceableRecordData() const {
   scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
   record_data->Set("picture_id", TracedValue::CreateIDRef(this).release());
   record_data->Set("layer_rect", MathUtil::AsValue(layer_rect_).release());
   return TracedValue::FromValue(record_data.release());
 }
 
 }  // namespace cc