cc: Only make num_threads - 1 SkPicture clones.

cc/resources/raster_worker_pool.cc

 // Copyright 2013 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/raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/json/json_writer.h"
@@ skipping 432 matching lines @@
  private:
   virtual ~RasterRequiredForActivationFinishedWorkerPoolTaskImpl() {}
 
   base::TimeTicks activation_delay_end_time_;
   const size_t tasks_required_for_activation_count_;
 
   DISALLOW_COPY_AND_ASSIGN(
       RasterRequiredForActivationFinishedWorkerPoolTaskImpl);
 };
 
+class RasterTaskGraphRunner : public internal::TaskGraphRunner {
+ public:
+  RasterTaskGraphRunner()
+      : internal::TaskGraphRunner(RasterWorkerPool::GetNumRasterThreads(),
+                                  "CompositorRaster") {}
+};
+base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
+    LAZY_INSTANCE_INITIALIZER;
+
 const int kDefaultNumRasterThreads = 1;
 
 int g_num_raster_threads = 0;
 
 }  // namespace
 
 namespace internal {
 
 WorkerPoolTask::WorkerPoolTask() : did_schedule_(false), did_complete_(false) {}
 
@@ skipping 84 matching lines @@
 RasterWorkerPool::RasterTask::RasterTask() {}
 
 RasterWorkerPool::RasterTask::RasterTask(
     internal::RasterWorkerPoolTask* internal)
     : internal_(internal) {}
 
 void RasterWorkerPool::RasterTask::Reset() { internal_ = NULL; }
 
 RasterWorkerPool::RasterTask::~RasterTask() {}
 
+// This allows an external rasterize on-demand system to run raster tasks
+// with highest priority using the same task graph runner instance.
+unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u;
 // Task priorities that make sure raster finished tasks run before any
 // remaining raster tasks.
-unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 1u;
+unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 2u;
 unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =
-    0u;
-unsigned RasterWorkerPool::kRasterTaskPriorityBase = 2u;
+    1u;
+unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u;
 
 RasterWorkerPool::RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
                                    ResourceProvider* resource_provider,
                                    ContextProvider* context_provider)
     : task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner_->GetNamespaceToken()),
       client_(NULL),
       resource_provider_(resource_provider),
       context_provider_(context_provider),
       weak_ptr_factory_(this) {}
@@ skipping 10 matching lines @@
 
 // static
 int RasterWorkerPool::GetNumRasterThreads() {
   if (!g_num_raster_threads)
     g_num_raster_threads = kDefaultNumRasterThreads;
 
   return g_num_raster_threads;
 }
 
 // static
+internal::TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
+  return g_task_graph_runner.Pointer();
+}
+
+// static
 RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     const Resource* resource,
     PicturePileImpl* picture_pile,
     const gfx::Rect& content_rect,
     float contents_scale,
     RasterMode raster_mode,
     TileResolution tile_resolution,
     int layer_id,
     const void* tile_id,
     int source_frame_number,
@@ skipping 191 matching lines @@
     if (decode_it == graph->nodes.end())
       InsertNodeForTask(graph, decode_task, priority, 0u);
 
     graph->edges.push_back(internal::TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, priority, dependencies);
 }
 
 }  // namespace cc