Revert "cc: Simplify raster task completion notification logic"

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 84 matching lines @@
     size_t max_transfer_buffer_usage_bytes)
     : RasterWorkerPool(resource_provider, num_threads),
       shutdown_(false),
       scheduled_raster_task_count_(0),
       bytes_pending_upload_(0),
       max_bytes_pending_upload_(max_transfer_buffer_usage_bytes),
       has_performed_uploads_since_last_flush_(false),
       check_for_completed_raster_tasks_pending_(false),
       should_notify_client_if_no_tasks_are_pending_(false),
       should_notify_client_if_no_tasks_required_for_activation_are_pending_(
-          false),
-      raster_finished_task_pending_(false),
-      raster_required_for_activation_finished_task_pending_(false) {
+          false) {
 }
 
 PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
   DCHECK(shutdown_);
   DCHECK(!check_for_completed_raster_tasks_pending_);
   DCHECK_EQ(0u, pixel_buffer_tasks_.size());
   DCHECK_EQ(0u, tasks_with_pending_upload_.size());
   DCHECK_EQ(0u, completed_tasks_.size());
 }
 
@@ skipping 132 matching lines @@
     completed_tasks.pop_front();
   }
 }
 
 void PixelBufferRasterWorkerPool::OnRasterTasksFinished() {
   // |should_notify_client_if_no_tasks_are_pending_| can be set to false as
   // a result of a scheduled CheckForCompletedRasterTasks() call. No need to
   // perform another check in that case as we've already notified the client.
   if (!should_notify_client_if_no_tasks_are_pending_)
     return;
-  raster_finished_task_pending_ = false;
 
   // Call CheckForCompletedRasterTasks() when we've finished running all
   // raster tasks needed since last time ScheduleTasks() was called.
   // This reduces latency between the time when all tasks have finished
   // running and the time when the client is notified.
   CheckForCompletedRasterTasks();
 }
 
 void PixelBufferRasterWorkerPool::OnRasterTasksRequiredForActivationFinished() {
   // Analogous to OnRasterTasksFinished(), there's no need to call
   // CheckForCompletedRasterTasks() if the client has already been notified.
   if (!should_notify_client_if_no_tasks_required_for_activation_are_pending_)
     return;
-  raster_required_for_activation_finished_task_pending_ = false;
 
   // This reduces latency between the time when all tasks required for
   // activation have finished running and the time when the client is
   // notified.
   CheckForCompletedRasterTasks();
 }
 
 void PixelBufferRasterWorkerPool::FlushUploads() {
   if (!has_performed_uploads_since_last_flush_)
     return;
@@ skipping 98 matching lines @@
   check_for_completed_raster_tasks_callback_.Cancel();
   check_for_completed_raster_tasks_pending_ = false;
 
   RasterWorkerPool::CheckForCompletedTasks();
   CheckForCompletedUploads();
   FlushUploads();
 
   // Determine what client notifications to generate.
   bool will_notify_client_that_no_tasks_required_for_activation_are_pending =
       (should_notify_client_if_no_tasks_required_for_activation_are_pending_ &&
-       !raster_required_for_activation_finished_task_pending_ &&
        !HasPendingTasksRequiredForActivation());
   bool will_notify_client_that_no_tasks_are_pending =
       (should_notify_client_if_no_tasks_are_pending_ &&
-       !raster_finished_task_pending_ &&
        !HasPendingTasks());
 
   // Adjust the need to generate notifications before scheduling more tasks.
   should_notify_client_if_no_tasks_required_for_activation_are_pending_ &=
       !will_notify_client_that_no_tasks_required_for_activation_are_pending;
   should_notify_client_if_no_tasks_are_pending_ &=
       !will_notify_client_that_no_tasks_are_pending;
 
   scheduled_raster_task_count_ = 0;
   if (PendingRasterTaskCount())
@@ skipping 125 matching lines @@
   DCHECK_LE(scheduled_raster_task_required_for_activation_count,
             tasks_required_for_activation_.size());
   // Schedule OnRasterTasksRequiredForActivationFinished call only when
   // notification is pending and throttling is not preventing all pending
   // tasks required for activation from being scheduled.
   if (scheduled_raster_task_required_for_activation_count ==
       tasks_required_for_activation_.size() &&
       should_notify_client_if_no_tasks_required_for_activation_are_pending_) {
     new_raster_required_for_activation_finished_task =
         CreateRasterRequiredForActivationFinishedTask();
-    raster_required_for_activation_finished_task_pending_ = true;
     internal::GraphNode* raster_required_for_activation_finished_node =
         CreateGraphNodeForTask(
             new_raster_required_for_activation_finished_task.get(),
             0u,  // Priority 0
             &graph);
     AddDependenciesToGraphNode(
         raster_required_for_activation_finished_node,
         tasks[REQUIRED_FOR_ACTIVATION_TYPE].container());
   }
 
   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() &&
       should_notify_client_if_no_tasks_are_pending_) {
     new_raster_finished_task = CreateRasterFinishedTask();
-    raster_finished_task_pending_ = true;
     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 100 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