cc: Implement raster worker thread pool using shared queue.

This is an implementation of the worker pool using as shared queue
instead of using message loops. It improves efficiency and load
balancing between threads significantly.

This changes the behavior of cheap tasks a bit. Cheap tasks are now
shared between compositor thread and worker threads. Compositor
thread will run cheap tasks until time limit is reached. Worker threads
can always run cheap tasks. The time limit decision for cheap tasks is
moved to the consumer where this decision can be properly made.

BUG=178239


Review URL: https://chromiumcodereview.appspot.com/12398002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@187145 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 19 insertions, 9 deletions

diff --git a/cc/raster_worker_pool.cc b/cc/raster_worker_pool.cc
index e0210e6..316b962 100644
--- a/cc/raster_worker_pool.cc
+++ b/cc/raster_worker_pool.cc
@@ -13,33 +13,44 @@ namespace {
 class RasterWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   RasterWorkerPoolTaskImpl(PicturePileImpl* picture_pile,
+                           bool is_cheap,
                            const RasterWorkerPool::RasterCallback& task,
                            const base::Closure& reply)
       : internal::WorkerPoolTask(reply),
         picture_pile_(picture_pile),
+        is_cheap_(is_cheap),
         task_(task) {
     DCHECK(picture_pile_);
   }
 
+  virtual bool IsCheap() OVERRIDE { return is_cheap_; }
+
   virtual void WillRunOnThread(unsigned thread_index) OVERRIDE {
     picture_pile_ = picture_pile_->GetCloneForDrawingOnThread(thread_index);
   }
 
   virtual void Run(RenderingStats* rendering_stats) OVERRIDE {
     task_.Run(picture_pile_.get(), rendering_stats);
-    base::subtle::Release_Store(&completed_, 1);
   }
 
  private:
   scoped_refptr<PicturePileImpl> picture_pile_;
+  bool is_cheap_;
   RasterWorkerPool::RasterCallback task_;
 };
 
+const char* kWorkerThreadNamePrefix = "CompositorRaster";
+
+const int kCheckForCompletedTasksDelayMs = 6;
+
 }  // namespace
 
 RasterWorkerPool::RasterWorkerPool(
-    WorkerPoolClient* client, size_t num_threads)
-    : WorkerPool(client, num_threads) {
+    WorkerPoolClient* client, size_t num_threads) : WorkerPool(
+        client,
+        num_threads,
+        base::TimeDelta::FromMilliseconds(kCheckForCompletedTasksDelayMs),
+        kWorkerThreadNamePrefix) {
 }
 
 RasterWorkerPool::~RasterWorkerPool() {
@@ -49,12 +60,11 @@ void RasterWorkerPool::PostRasterTaskAndReply(PicturePileImpl* picture_pile,
                                               bool is_cheap,
                                               const RasterCallback& task,
                                               const base::Closure& reply) {
-  PostTask(
-      make_scoped_ptr(new RasterWorkerPoolTaskImpl(
-                          picture_pile,
-                          task,
-                          reply)).PassAs<internal::WorkerPoolTask>(),
-                      is_cheap);
+  PostTask(make_scoped_ptr(new RasterWorkerPoolTaskImpl(
+                               picture_pile,
+                               is_cheap,
+                               task,
+                               reply)).PassAs<internal::WorkerPoolTask>());
 }
 
 }  // namespace cc