cc: Fix data race in cc::TaskState::IsFinished.

cc/tiles/tile_manager.cc

 // Copyright 2012 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/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 79 matching lines @@
 
     raster_buffer_->Playback(raster_source_.get(), content_rect_,
                              invalid_content_rect_, new_content_id_,
                              contents_scale_, playback_settings_);
   }
 
   // Overridden from TileTask:
   void OnTaskCompleted() override {
     DCHECK(origin_thread_checker_.CalledOnValidThread());
 
+    // Here calling state().IsCanceled() is thread-safe, because this task is
+    // already concluded as FINISHED or CANCELLED and no longer will be worked
+    // upon by task graph runner.
     tile_manager_->OnRasterTaskCompleted(std::move(raster_buffer_), tile_,
                                          resource_, state().IsCanceled());
   }
 
  protected:
   ~RasterTaskImpl() override {
     DCHECK(origin_thread_checker_.CalledOnValidThread());
     DCHECK(!raster_buffer_);
   }
 
@@ skipping 73 matching lines @@
 }
 
 void InsertNodeForDecodeTask(TaskGraph* graph,
                              TileTask* task,
                              bool use_foreground_category,
                              uint16_t priority) {
   uint32_t dependency_count = 0u;
   if (task->dependencies().size()) {
     DCHECK_EQ(task->dependencies().size(), 1u);
     auto* dependency = task->dependencies()[0].get();
-    if (!dependency->state().IsFinished()) {
+    if (!dependency->HasCompleted()) {
       InsertNodeForDecodeTask(graph, dependency, use_foreground_category,
                               priority);
       graph->edges.push_back(TaskGraph::Edge(dependency, task));
       dependency_count = 1u;
     }
   }
   InsertNodeForTask(graph, task,
                     TaskCategoryForTileTask(task, use_foreground_category),
                     priority, dependency_count);
 }
 
 void InsertNodesForRasterTask(TaskGraph* graph,
                               TileTask* raster_task,
                               const TileTask::Vector& decode_tasks,
                               size_t priority,
                               bool use_foreground_category) {
   size_t dependencies = 0u;
 
   // Insert image decode tasks.
   for (TileTask::Vector::const_iterator it = decode_tasks.begin();
        it != decode_tasks.end(); ++it) {
     TileTask* decode_task = it->get();
 
     // Skip if already decoded.
-    if (decode_task->state().IsFinished())
+    if (decode_task->HasCompleted())
       continue;
 
     dependencies++;
 
     // Add decode task if it doesn't already exist in graph.
     TaskGraph::Node::Vector::iterator decode_it =
         std::find_if(graph->nodes.begin(), graph->nodes.end(),
                      [decode_task](const TaskGraph::Node& node) {
                        return node.task == decode_task;
                      });
@@ skipping 568 matching lines @@
     Tile* tile = prioritized_tile.tile();
 
     DCHECK(tile->draw_info().requires_resource());
     DCHECK(!tile->draw_info().resource_);
 
     if (!tile->raster_task_)
       tile->raster_task_ = CreateRasterTask(prioritized_tile);
 
     TileTask* task = tile->raster_task_.get();
 
-    // The canceled state implies that task is completed as canceled. The task
-    // is modified to canceled state in TaskGraphWorkQueue::ScheduleTasks() with
-    // lock acquired. Canceled task gets collected before next scheduling,
-    // TileManager::ScheduleTasks(), happens. So if tile which had task canceled
-    // would get new raster task. As worker and origin threads run parallely,
-    // the tasks may be finished during schedule. Avoid sheduling raster tasks
-    // which have finished and those tasks should have all their dependencies
-    // finished. If task gets finished after it is checked, then it gets skipped
-    // in TaskGraphWorkQueue::ScheduleTasks().
-    DCHECK(!task->state().IsCanceled());
-    if (task->state().IsFinished()) {
-#if DCHECK_IS_ON()
-      // Check if there is any dependency which is not finished.
-      for (auto& decode_task : task->dependencies())
-        DCHECK(decode_task->state().IsFinished());
-#endif
-      continue;
-    }
+    DCHECK(!task->HasCompleted());
 
     if (tile->required_for_activation()) {
       required_for_activate_count++;
       graph_.edges.push_back(
           TaskGraph::Edge(task, required_for_activation_done_task.get()));
     }
     if (tile->required_for_draw()) {
       required_for_draw_count++;
       graph_.edges.push_back(
           TaskGraph::Edge(task, required_for_draw_done_task.get()));
@@ skipping 447 matching lines @@
 void TileManager::Signals::reset() {
   ready_to_activate = false;
   did_notify_ready_to_activate = false;
   ready_to_draw = false;
   did_notify_ready_to_draw = false;
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 }  // namespace cc