cc: Avoid scheduling empty raster task queue whenever possible.

cc/resources/raster_worker_pool_delegate.cc

Index: cc/resources/raster_worker_pool_delegate.cc
diff --git a/cc/resources/raster_worker_pool_delegate.cc b/cc/resources/raster_worker_pool_delegate.cc
index 6a2edaebf48b40044db08c3359b0c6bcfc3d89ef..f91f25a0a5b0336ee2fcf9b9ea9fb9a2631c8764 100644
--- a/cc/resources/raster_worker_pool_delegate.cc
+++ b/cc/resources/raster_worker_pool_delegate.cc
@@ -4,6 +4,8 @@
 
 #include "cc/resources/raster_worker_pool_delegate.h"
 
+#include "base/message_loop/message_loop_proxy.h"
+
 namespace cc {
 
 RasterWorkerPoolDelegate::RasterWorkerPoolDelegate(
@@ -13,8 +15,11 @@ RasterWorkerPoolDelegate::RasterWorkerPoolDelegate(
     : client_(client),
       raster_worker_pools_(raster_worker_pools,
                            raster_worker_pools + num_raster_worker_pools),
+      did_finish_running_tasks_pending_(num_raster_worker_pools, false),
       did_finish_running_tasks_pending_count_(0u),
-      did_finish_running_tasks_required_for_activation_pending_count_(0u) {
+      did_finish_running_tasks_required_for_activation_pending_count_(0u),
+      run_did_finish_running_tasks_pending_(false),
+      weak_ptr_factory_(this) {
   DCHECK(client_);
   for (RasterWorkerPoolVector::iterator it = raster_worker_pools_.begin();
        it != raster_worker_pools_.end();
@@ -41,12 +46,28 @@ void RasterWorkerPoolDelegate::Shutdown() {
 }
 
 void RasterWorkerPoolDelegate::ScheduleTasks(RasterTaskQueue* raster_queue) {
-  for (size_t i = 0; i < raster_worker_pools_.size(); ++i)
+  size_t did_finish_running_tasks_pending_count = 0u;
+  for (size_t i = 0u; i < raster_worker_pools_.size(); ++i) {
+    // Empty queue doesn't have to be scheduled unless raster worker pool has
+    // pending DidFinishRunningTasks notifications.
+    if (raster_queue[i].items.empty() && !did_finish_running_tasks_pending_[i])
+      continue;
+
+    did_finish_running_tasks_pending_[i] = true;
+    ++did_finish_running_tasks_pending_count;
     raster_worker_pools_[i]->ScheduleTasks(&raster_queue[i]);
+  }
 
-  did_finish_running_tasks_pending_count_ = raster_worker_pools_.size();
+  did_finish_running_tasks_pending_count_ =
+      did_finish_running_tasks_pending_count;
   did_finish_running_tasks_required_for_activation_pending_count_ =
-      raster_worker_pools_.size();
+      did_finish_running_tasks_pending_count;
+
+  // Need to schedule a call to RunDidFinishRunningTasks() when no
+  // DidFinishRunningTasks notifications are expected from raster worker pool
+  // instances.
+  if (!did_finish_running_tasks_pending_count)
+    ScheduleRunDidFinishRunningTasks();
 }
 
 void RasterWorkerPoolDelegate::CheckForCompletedTasks() {
@@ -58,23 +79,53 @@ void RasterWorkerPoolDelegate::CheckForCompletedTasks() {
 
 bool RasterWorkerPoolDelegate::ShouldForceTasksRequiredForActivationToComplete()
     const {
-  DCHECK(client_);
   return client_->ShouldForceTasksRequiredForActivationToComplete();
 }
 
 void RasterWorkerPoolDelegate::DidFinishRunningTasks() {
   DCHECK_LT(0u, did_finish_running_tasks_pending_count_);
-  if (--did_finish_running_tasks_pending_count_)
-    return;
-  client_->DidFinishRunningTasks();
+  --did_finish_running_tasks_pending_count_;
+  RunDidFinishRunningTasks();
 }
 
 void RasterWorkerPoolDelegate::DidFinishRunningTasksRequiredForActivation() {
   DCHECK_LT(0u,
             did_finish_running_tasks_required_for_activation_pending_count_);
-  if (--did_finish_running_tasks_required_for_activation_pending_count_)
+  --did_finish_running_tasks_required_for_activation_pending_count_;
+  RunDidFinishRunningTasks();
+}
+
+void RasterWorkerPoolDelegate::ScheduleRunDidFinishRunningTasks() {
+  if (run_did_finish_running_tasks_pending_)
     return;
-  client_->DidFinishRunningTasksRequiredForActivation();
+
+  base::MessageLoopProxy::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&RasterWorkerPoolDelegate::OnRunDidFinishRunningTasks,
+                 weak_ptr_factory_.GetWeakPtr()));
+  run_did_finish_running_tasks_pending_ = true;
+}
+
+void RasterWorkerPoolDelegate::OnRunDidFinishRunningTasks() {
+  DCHECK(run_did_finish_running_tasks_pending_);
+  run_did_finish_running_tasks_pending_ = false;
+  RunDidFinishRunningTasks();
+}
+
+void RasterWorkerPoolDelegate::RunDidFinishRunningTasks() {
+  if (!did_finish_running_tasks_required_for_activation_pending_count_)
+    client_->DidFinishRunningTasksRequiredForActivation();
+
+  if (!did_finish_running_tasks_pending_count_)
+    client_->DidFinishRunningTasks();
+
+  // Reset |run_did_finish_running_tasks_pending_| vector if no notifications
+  // are pending.
+  if (!did_finish_running_tasks_required_for_activation_pending_count_ &&
+      !did_finish_running_tasks_pending_count_) {

[reveman, 2014/02/20 00:11:54]

Moved this here as there's no guarantee that required-for-activation arrives
first.

+    did_finish_running_tasks_pending_.assign(
+        did_finish_running_tasks_pending_.size(), false);
+  }
 }
 
 }  // namespace cc