cc: Only make num_threads - 1 SkPicture clones.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 60 matching lines @@
  public:
   SimpleSwapFence() : has_passed_(false) {}
   virtual bool HasPassed() OVERRIDE { return has_passed_; }
   void SetHasPassed() { has_passed_ = true; }
 
  private:
   virtual ~SimpleSwapFence() {}
   bool has_passed_;
 };
 
+class OnDemandRasterTaskImpl : public internal::Task {
+ public:
+  OnDemandRasterTaskImpl(PicturePileImpl* picture_pile,
+                         SkBitmap* bitmap,
+                         gfx::Rect contents_rect,
+                         float contents_scale)
+      : picture_pile_(picture_pile),
+        bitmap_(bitmap),
+        contents_rect_(contents_rect),
+        contents_scale_(contents_scale) {
+    DCHECK(picture_pile_);
+    DCHECK(bitmap_);
+  }
+
+  // Overridden from internal::Task:
+  virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
+    TRACE_EVENT0("cc", "OnDemandRasterTaskImpl::RunOnWorkerThread");
+    SkBitmapDevice device(*bitmap_);
+    SkCanvas canvas(&device);
+    picture_pile_->RasterToBitmap(
+        &canvas, contents_rect_, contents_scale_, NULL);
+  }
+
+ protected:
+  virtual ~OnDemandRasterTaskImpl() {}
+
+ private:
+  PicturePileImpl* picture_pile_;
+  SkBitmap* bitmap_;
+  const gfx::Rect contents_rect_;
+  const float contents_scale_;
+
+  DISALLOW_COPY_AND_ASSIGN(OnDemandRasterTaskImpl);
+};
+
 bool NeedsIOSurfaceReadbackWorkaround() {
 #if defined(OS_MACOSX)
   // This isn't strictly required in DumpRenderTree-mode when Mesa is used,
   // but it doesn't seem to hurt.
   return true;
 #else
   return false;
 #endif
 }
 
@@ skipping 1622 matching lines @@
                                             GL_TEXTURE_2D,
                                             GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
                                             GL_CLAMP_TO_EDGE,
                                             ResourceProvider::TextureUsageAny,
                                             quad->texture_format);
   }
 
   SkBitmapDevice device(on_demand_tile_raster_bitmap_);
   SkCanvas canvas(&device);
 
-  quad->picture_pile->RasterToBitmap(
-      &canvas, quad->content_rect, quad->contents_scale, NULL);
+  internal::TaskGraphRunner* task_graph_runner =
+      RasterWorkerPool::GetTaskGraphRunner();
+  // Make sure we have a unique task namespace token.
+  if (!on_demand_task_namespace_.IsValid())
+    on_demand_task_namespace_ = task_graph_runner->GetNamespaceToken();
+
+  // Create a raster task for for tile.
+  scoped_refptr<internal::Task> on_demand_raster_task(
+      new OnDemandRasterTaskImpl(quad->picture_pile,
+                                 &on_demand_tile_raster_bitmap_,
+                                 quad->content_rect,
+                                 quad->contents_scale));
+
+  // Construct a task graph that contains this single raster task.
+  internal::TaskGraph graph;
+  graph.nodes.push_back(
+      internal::TaskGraph::Node(on_demand_raster_task.get(),
+                                RasterWorkerPool::kOnDemandRasterTaskPriority,
+                                0u));
+
+  // Schedule task and wait for task grap runner to finish running it.
+  task_graph_runner->SetTaskGraph(on_demand_task_namespace_, &graph);
+  task_graph_runner->WaitForTasksToFinishRunning(on_demand_task_namespace_);
+
+  // Collect task now that it has finished running.
+  internal::Task::Vector completed_tasks;
+  task_graph_runner->CollectCompletedTasks(on_demand_task_namespace_,
+                                           &completed_tasks);
+  DCHECK_EQ(1u, completed_tasks.size());
+  DCHECK_EQ(completed_tasks[0], on_demand_raster_task.get());
 
   uint8_t* bitmap_pixels = NULL;
   SkBitmap on_demand_tile_raster_bitmap_dest;
   SkBitmap::Config config = SkBitmapConfig(quad->texture_format);
   if (on_demand_tile_raster_bitmap_.getConfig() != config) {
     on_demand_tile_raster_bitmap_.copyTo(&on_demand_tile_raster_bitmap_dest,
                                          config);
     // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
     // bitmap data. This check will be removed once crbug.com/293728 is fixed.
     CHECK_EQ(0u, on_demand_tile_raster_bitmap_dest.rowBytes() % 4);
@@ skipping 1270 matching lines @@
   is_scissor_enabled_ = false;
   GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   scissor_rect_needs_reset_ = true;
 }
 
 bool GLRenderer::IsContextLost() {
   return output_surface_->context_provider()->IsContextLost();
 }
 
 }  // namespace cc