Shared Raster Worker Threads

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 "base/debug/trace_event_synthetic_delay.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
@@ skipping 355 matching lines @@
   void RunOnOriginThread() const {
     on_raster_finished_callback_.Run(this);
   }
 
   scoped_refptr<base::MessageLoopProxy> origin_loop_;
   const Callback on_raster_finished_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl);
 };
 
+const int kDefaultNumRasterThreads = 1;
+
+int g_num_raster_threads = 0;
+
 class RasterRequiredForActivationFinishedWorkerPoolTaskImpl
     : public RasterFinishedWorkerPoolTaskImpl {
  public:
   RasterRequiredForActivationFinishedWorkerPoolTaskImpl(
       const Callback& on_raster_finished_callback,
       size_t tasks_required_for_activation_count)
       : RasterFinishedWorkerPoolTaskImpl(on_raster_finished_callback),
         tasks_required_for_activation_count_(
             tasks_required_for_activation_count) {
     if (tasks_required_for_activation_count_) {
@@ skipping 17 matching lines @@
  private:
   virtual ~RasterRequiredForActivationFinishedWorkerPoolTaskImpl() {}
 
   base::TimeTicks activation_delay_end_time_;
   const size_t tasks_required_for_activation_count_;
 
   DISALLOW_COPY_AND_ASSIGN(
       RasterRequiredForActivationFinishedWorkerPoolTaskImpl);
 };
 
-const char* kWorkerThreadNamePrefix = "CompositorRaster";
 
 }  // namespace
 
 namespace internal {
 
 RasterWorkerPoolTask::RasterWorkerPoolTask(const Resource* resource,
                                            TaskVector* dependencies,
                                            bool use_gpu_rasterization)
     : did_run_(false),
       did_complete_(false),
@@ skipping 125 matching lines @@
     SkPixelRef* pixel_ref,
     int layer_id,
     RenderingStatsInstrumentation* stats_instrumentation,
     const Task::Reply& reply) {
   return Task(new ImageDecodeWorkerPoolTaskImpl(pixel_ref,
                                                 layer_id,
                                                 stats_instrumentation,
                                                 reply));
 }
 
+// static
+void RasterWorkerPool::SetNumRasterThreads(int num_threads) {
+  DCHECK_LT(0, num_threads);
+  DCHECK_EQ(0, g_num_raster_threads);
+
+  g_num_raster_threads = num_threads;
+}
+
+// static
+int WorkerPool::GetNumRasterThreads() {
+  if (!g_num_raster_threads)
+    g_num_raster_threads = kDefaultNumRasterThreads;
+
+  return g_num_raster_threads;
+}
+
 RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider,
-                                   ContextProvider* context_provider,
-                                   size_t num_threads)
-    : WorkerPool(num_threads, kWorkerThreadNamePrefix),
-      client_(NULL),
+                                   ContextProvider* context_provider)
+    : client_(NULL),
       resource_provider_(resource_provider),
       context_provider_(context_provider),
       weak_ptr_factory_(this) {
 }
 
 RasterWorkerPool::~RasterWorkerPool() {
 }
 
 void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
   client_ = client;
@@ skipping 156 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc