cc: Use SkMultiPicture for GPU rasterization

GpuRasterWorkerPool holds an SkMultiPicture, the RasterBufferImpl is
created with a pointer to SkMultiPicture, and returns the
SkPictureRecorder's canvas when AquireSkCanvas is called.  When the
canvas is released, we get the surface canvas and pass it to the
multipicture along with the recorded picture.

When we're finished with all of the tiles, we draw the multipicture.

Updated Picture::Raster() to call canvas->drawPicture(), instead of
picture->draw().  This is required to prevent parsing the skia ops
twice when using the multipicturedraw, since picture->draw() always
parses the ops, whereas canvas->drawPicture() might parse the ops,
or it might simply place the whole picture on the canvas (as it will
for the recorder's canvas)

BUG=skia:2315

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

Cr-Commit-Position: refs/heads/master@{#296227}

cc/resources/gpu_raster_worker_pool.cc

@@ -13,6 +13,8 @@
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_gpu_raster.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "third_party/skia/include/core/SkMultiPictureDraw.h"
+#include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/utils/SkNullCanvas.h"
@@ -23,19 +25,23 @@ namespace {
 class RasterBufferImpl : public RasterBuffer {
  public:
   RasterBufferImpl(ResourceProvider* resource_provider,
-                   const Resource* resource)
+                   const Resource* resource,
+                   SkMultiPictureDraw* multi_picture_draw)
       : resource_provider_(resource_provider),
         resource_(resource),
-        surface_(resource_provider->LockForWriteToSkSurface(resource->id())) {}
+        surface_(resource_provider->LockForWriteToSkSurface(resource->id())),
+        multi_picture_draw_(multi_picture_draw) {}
   virtual ~RasterBufferImpl() {
     resource_provider_->UnlockForWriteToSkSurface(resource_->id());
   }
 
   // Overridden from RasterBuffer:
   virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE {
-    skia::RefPtr<SkCanvas> canvas = surface_
-                                        ? skia::SharePtr(surface_->getCanvas())
-                                        : skia::AdoptRef(SkCreateNullCanvas());
+    if (!surface_)
+      return skia::AdoptRef(SkCreateNullCanvas());
+
+    skia::RefPtr<SkCanvas> canvas = skia::SharePtr(recorder_.beginRecording(
+        resource_->size().width(), resource_->size().height()));
 
     // Balanced with restore() call in ReleaseSkCanvas. save()/restore() calls
     // are needed to ensure that canvas returns to its previous state after use.
@@ -43,14 +49,23 @@ class RasterBufferImpl : public RasterBuffer {
     return canvas;
   }
   virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE {
+    if (!surface_)
+      return;
+
     // Balanced with save() call in AcquireSkCanvas.
     canvas->restore();
+
+    // Add the canvas and recorded picture to |multi_picture_draw_|.
+    skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder_.endRecording());
+    multi_picture_draw_->add(surface_->getCanvas(), picture.get());
   }
 
  private:
   ResourceProvider* resource_provider_;
   const Resource* resource_;
   SkSurface* surface_;
+  SkMultiPictureDraw* multi_picture_draw_;
+  SkPictureRecorder recorder_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
 };
@@ -188,7 +203,7 @@ scoped_ptr<RasterBuffer> GpuRasterWorkerPool::AcquireBufferForRaster(
   resource_provider_->AcquireSkSurface(resource->id());
 
   return make_scoped_ptr<RasterBuffer>(
-      new RasterBufferImpl(resource_provider_, resource));
+      new RasterBufferImpl(resource_provider_, resource, &multi_picture_draw_));
 }
 
 void GpuRasterWorkerPool::ReleaseBufferForRaster(
@@ -224,6 +239,10 @@ void GpuRasterWorkerPool::RunTasksOnOriginThread() {
 
   ScopedGpuRaster gpu_raster(context_provider_);
   task_graph_runner_->RunUntilIdle();
+
+  // Draw each all of the pictures that were collected.  This will also clear
+  // the pictures and canvases added to |multi_picture_draw_|
+  multi_picture_draw_.draw();
 }
 
 }  // namespace cc

cc/resources/gpu_raster_worker_pool.h

@@ -8,6 +8,7 @@
 #include "base/memory/weak_ptr.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/rasterizer.h"
+#include "third_party/skia/include/core/SkMultiPictureDraw.h"
 
 namespace cc {
 class ContextProvider;
@@ -54,6 +55,7 @@ class CC_EXPORT GpuRasterWorkerPool : public RasterWorkerPool,
   RasterizerClient* client_;
   ContextProvider* context_provider_;
   ResourceProvider* resource_provider_;
+  SkMultiPictureDraw multi_picture_draw_;
 
   bool run_tasks_on_origin_thread_pending_;
 

cc/resources/picture.cc

@@ -350,8 +350,14 @@ int Picture::Raster(SkCanvas* canvas,
   canvas->translate(layer_rect_.x(), layer_rect_.y());
   if (playback_) {
     playback_->draw(canvas);
-  } else {
+  } else if (callback) {
+    // If we have a callback, we need to call |draw()|, |drawPicture()| doesn't
+    // take a callback.  This is used by |AnalysisCanvas| to early out.
     picture_->draw(canvas, callback);
+  } else {
+    // Prefer to call |drawPicture()| on the canvas since it could place the
+    // entire picture on the canvas instead of parsing the skia operations.
+    canvas->drawPicture(picture_.get());
   }
   SkIRect bounds;
   canvas->getClipDeviceBounds(&bounds);