cc: Fix logic for detecting when raster tasks were throttled

cc/resources/pixel_buffer_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/pixel_buffer_raster_worker_pool.h"
 
 #include "base/containers/stack_container.h"
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/debug/traced_value.h"
@@ skipping 429 matching lines @@
   enum RasterTaskType {
     PREPAINT_TYPE = 0,
     REQUIRED_FOR_ACTIVATION_TYPE = 1,
     NUM_TYPES = 2
   };
   NodeVector tasks[NUM_TYPES];
   unsigned priority = 2u;  // 0-1 reserved for RasterFinished tasks.
   TaskGraph graph;
 
   size_t bytes_pending_upload = bytes_pending_upload_;
+  bool did_throttle_raster_tasks = false;
 
   for (RasterTaskVector::const_iterator it = raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->get();
 
     // |pixel_buffer_tasks_| contains all tasks that have not yet completed.
     TaskMap::iterator pixel_buffer_it = pixel_buffer_tasks_.find(task);
     if (pixel_buffer_it == pixel_buffer_tasks_.end())
       continue;
 
     // HasFinishedRunning() will return true when set pixels has completed.
     if (task->HasFinishedRunning()) {
       DCHECK(std::find(completed_tasks_.begin(),
                        completed_tasks_.end(),
                        task) != completed_tasks_.end());
       continue;
     }
 
     // All raster tasks need to be throttled by bytes of pending uploads.
     size_t new_bytes_pending_upload = bytes_pending_upload;
     new_bytes_pending_upload += task->resource()->bytes();
-    if (new_bytes_pending_upload > max_bytes_pending_upload_)
+    if (new_bytes_pending_upload > max_bytes_pending_upload_) {
+      did_throttle_raster_tasks = true;
       break;
+    }
 
     internal::WorkerPoolTask* pixel_buffer_task = pixel_buffer_it->second.get();
 
     // If raster has finished, just update |bytes_pending_upload|.
     if (pixel_buffer_task && pixel_buffer_task->HasCompleted()) {
       bytes_pending_upload = new_bytes_pending_upload;
       continue;
     }
 
     // Throttle raster tasks based on kMaxScheduledRasterTasks.
     size_t scheduled_raster_task_count =
         tasks[PREPAINT_TYPE].container().size() +
         tasks[REQUIRED_FOR_ACTIVATION_TYPE].container().size();
-    if (scheduled_raster_task_count >= kMaxScheduledRasterTasks)
+    if (scheduled_raster_task_count >= kMaxScheduledRasterTasks) {
+      did_throttle_raster_tasks = true;
       break;
+    }
 
     // Update |bytes_pending_upload| now that task has cleared all
     // throttling limits.
     bytes_pending_upload = new_bytes_pending_upload;
 
     RasterTaskType type = IsRasterTaskRequiredForActivation(task) ?
         REQUIRED_FOR_ACTIVATION_TYPE :
         PREPAINT_TYPE;
 
     // Use existing pixel buffer task if available.
@@ skipping 56 matching lines @@
   }
 
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task;
 
   size_t scheduled_raster_task_count =
       tasks[PREPAINT_TYPE].container().size() +
       tasks[REQUIRED_FOR_ACTIVATION_TYPE].container().size();
   DCHECK_LE(scheduled_raster_task_count, PendingRasterTaskCount());
   // Schedule OnRasterTasksFinished call only when notification is pending
   // and throttling is not preventing all pending tasks from being scheduled.
-  if (scheduled_raster_task_count == PendingRasterTaskCount() &&
+  if (!did_throttle_raster_tasks &&
       should_notify_client_if_no_tasks_are_pending_) {
     new_raster_finished_task = CreateRasterFinishedTask();
     internal::GraphNode* raster_finished_node =
         CreateGraphNodeForTask(new_raster_finished_task.get(),
                                1u,  // Priority 1
                                &graph);
     for (unsigned type = 0; type < NUM_TYPES; ++type) {
       AddDependenciesToGraphNode(
           raster_finished_node,
           tasks[type].container());
@@ skipping 103 matching lines @@
 
   throttle_state->SetInteger("bytes_available_for_upload",
                              max_bytes_pending_upload_ - bytes_pending_upload_);
   throttle_state->SetInteger("bytes_pending_upload", bytes_pending_upload_);
   throttle_state->SetInteger("scheduled_raster_task_count",
                              scheduled_raster_task_count_);
   return throttle_state.PassAs<base::Value>();
 }
 
 }  // namespace cc