cc: GPU rasterize tiles synchronously in PrepareToDraw.

cc/resources/gpu_tile_task_worker_pool.cc

 // Copyright 2014 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/gpu_tile_task_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/output/context_provider.h"
@@ skipping 58 matching lines @@
   bool use_distance_field_text_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
 };
 
 }  // namespace
 
 // static
 scoped_ptr<TileTaskWorkerPool> GpuTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
+    TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     bool use_distance_field_text) {
-  return make_scoped_ptr<TileTaskWorkerPool>(
-      new GpuTileTaskWorkerPool(task_runner, context_provider,
-                                resource_provider, use_distance_field_text));
+  return make_scoped_ptr<TileTaskWorkerPool>(new GpuTileTaskWorkerPool(
+      task_runner, task_graph_runner, context_provider, resource_provider,
+      use_distance_field_text));
 }
 
 GpuTileTaskWorkerPool::GpuTileTaskWorkerPool(
     base::SequencedTaskRunner* task_runner,
+    TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     bool use_distance_field_text)
     : task_runner_(task_runner),
-      task_graph_runner_(new TaskGraphRunner),
+      task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner_->GetNamespaceToken()),
       context_provider_(context_provider),
       resource_provider_(resource_provider),
       run_tasks_on_origin_thread_pending_(false),
       use_distance_field_text_(use_distance_field_text),
       task_set_finished_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
   DCHECK(context_provider_);
 }
 
@@ skipping 61 matching lines @@
   }
 
   for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
     InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(),
                       kTaskSetFinishedTaskPriority, task_count[task_set]);
   }
 
   ScheduleTasksOnOriginThread(this, &graph_);
   task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
 
-  ScheduleRunTasksOnOriginThread();
-
   std::copy(new_task_set_finished_tasks,
             new_task_set_finished_tasks + kNumberOfTaskSets,
             task_set_finished_tasks_);
 }
 
 void GpuTileTaskWorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::CheckForCompletedTasks");
 
   task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                             &completed_tasks_);
-  for (Task::Vector::const_iterator it = completed_tasks_.begin();
-       it != completed_tasks_.end(); ++it) {
-    TileTask* task = static_cast<TileTask*>(it->get());
+  CompleteTasks(completed_tasks_);
+  completed_tasks_.clear();
+}
 
-    task->WillComplete();
-    task->CompleteOnOriginThread(this);
-    task->DidComplete();
+void GpuTileTaskWorkerPool::CompleteTasks(const Task::Vector& tasks) {
+  for (auto& task : tasks) {
+    RasterTask* raster_task = static_cast<RasterTask*>(task.get());
 
-    task->RunReplyOnOriginThread();
+    raster_task->WillComplete();
+    raster_task->CompleteOnOriginThread(this);
+    raster_task->DidComplete();
+
+    raster_task->RunReplyOnOriginThread();
   }
   completed_tasks_.clear();
 }
 
 scoped_ptr<RasterBuffer> GpuTileTaskWorkerPool::AcquireBufferForRaster(
     const Resource* resource) {
   return make_scoped_ptr<RasterBuffer>(
       new RasterBufferImpl(resource_provider_, resource, &multi_picture_draw_,
                            use_distance_field_text_));
 }
 
 void GpuTileTaskWorkerPool::ReleaseBufferForRaster(
     scoped_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
 void GpuTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) {
   TRACE_EVENT1("cc", "GpuTileTaskWorkerPool::OnTaskSetFinished", "task_set",
                task_set);
 
   DCHECK(tasks_pending_[task_set]);
   tasks_pending_[task_set] = false;
+
   client_->DidFinishRunningTileTasks(task_set);
 }
 
-void GpuTileTaskWorkerPool::ScheduleRunTasksOnOriginThread() {
-  if (run_tasks_on_origin_thread_pending_)
-    return;
-
-  task_runner_->PostTask(
-      FROM_HERE, base::Bind(&GpuTileTaskWorkerPool::RunTasksOnOriginThread,
-                            weak_ptr_factory_.GetWeakPtr()));
-  run_tasks_on_origin_thread_pending_ = true;
-}
-
-void GpuTileTaskWorkerPool::RunTasksOnOriginThread() {
-  TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::RunTasksOnOriginThread");
-
-  DCHECK(run_tasks_on_origin_thread_pending_);
-  run_tasks_on_origin_thread_pending_ = false;
-
-  ScopedGpuRaster gpu_raster(context_provider_);
-  task_graph_runner_->RunUntilIdle();
-
-  // Draw each all of the pictures that were collected.  This will also clear
-  // the pictures and canvases added to |multi_picture_draw_|
-  multi_picture_draw_.draw();
-}
-
 }  // namespace cc