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/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
+#include "base/strings/string_number_conversions.h"
+#include "cc/base/switches.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "skia/ext/lazy_pixel_ref.h"
 #include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace cc {
 
+const int kMinRasterThreads = 1;
+const int kMaxRasterThreads = 64;
+const int kDefaultNumRasterThreads = 1;
+
 namespace {
 
 // Subclass of Allocator that takes a suitably allocated pointer and uses
 // it as the pixel memory for the bitmap.
 class IdentityAllocator : public SkBitmap::Allocator {
  public:
   explicit IdentityAllocator(void* buffer) : buffer_(buffer) {}
   virtual bool allocPixelRef(SkBitmap* dst, SkColorTable*) OVERRIDE {
     dst->setPixels(buffer_);
     return true;
@@ skipping 283 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 char* kWorkerThreadNamePrefix = "CompositorRaster";
 
 }  // namespace
 
 namespace internal {
 
 RasterWorkerPoolTask::RasterWorkerPoolTask(
     const Resource* resource, TaskVector* dependencies)
     : did_run_(false),
       did_complete_(false),
       was_canceled_(false),
@@ skipping 121 matching lines @@
     skia::LazyPixelRef* pixel_ref,
     int layer_id,
     RenderingStatsInstrumentation* stats_instrumentation,
     const Task::Reply& reply) {
   return Task(new ImageDecodeWorkerPoolTaskImpl(pixel_ref,
                                                 layer_id,
                                                 stats_instrumentation,
                                                 reply));
 }
 
-RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider,
-                                   size_t num_threads)
-    : WorkerPool(num_threads, kWorkerThreadNamePrefix),
-      client_(NULL),
+// static
+int RasterWorkerPool::num_raster_threads_ = kDefaultNumRasterThreads;

[reveman, 2014/01/06 07:13:12]

move this to anonymous namespace above.

[sohanjg, 2014/01/06 09:57:29]

Done.

+void RasterWorkerPool::SetNumRasterThreads() {

[reveman, 2014/01/06 07:13:12]

the logic below should not be here. the idea is to not have any command line
parsing in cc/. this function should take a "num_thread" value instead and be
called from content/renderer/render_thread_impl.cc where command line parsing
can be done.

[sohanjg, 2014/01/06 09:57:29]

Done.

+  RasterWorkerPool::num_raster_threads_ = kDefaultNumRasterThreads;
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kNumRasterThreads)) {
+    std::string string_value =
+        command_line.GetSwitchValueASCII(switches::kNumRasterThreads);
+    int num_threads;
+    if (base::StringToInt(string_value, &num_threads) &&
+        num_threads >= kMinRasterThreads && num_threads <= kMaxRasterThreads)
+      RasterWorkerPool::num_raster_threads_ = num_threads;
+
+    LOG(WARNING) << "Failed to parse switch " <<
+                    switches::kNumRasterThreads  << ": " << string_value;
+  }
+}
+
+// static
+int RasterWorkerPool::GetNumRasterThreads() {
+  return RasterWorkerPool::num_raster_threads_;
+}
+
+RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider)
+    : client_(NULL),
       resource_provider_(resource_provider),
       weak_ptr_factory_(this) {
 }
 
 RasterWorkerPool::~RasterWorkerPool() {
 }
 
 void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
   client_ = client;
 }
@@ skipping 109 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc