cc: GPU rasterize tiles synchronously in PrepareToDraw

cc/resources/gpu_raster_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_raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/output/context_provider.h"
@@ skipping 106 matching lines @@
 }
 
 void GpuRasterWorkerPool::Shutdown() {
   TRACE_EVENT0("cc", "GpuRasterWorkerPool::Shutdown");
 
   TaskGraph empty;
   task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
   task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
 }
 
+void GpuRasterWorkerPool::RunTasks(RasterTaskQueue* queue) {
+  ScopedGpuRaster gpu_raster(context_provider_);
+
+  for (auto& item : queue->items) {
+    RasterTask* task = item.task;
+    DCHECK(!task->HasCompleted());
+
+    task->WillSchedule();
+    task->ScheduleOnOriginThread(this);
+    task->DidSchedule();
+
+    task->WillRun();
+    task->RunOnWorkerThread();
+    task->DidRun();
+
+    completed_tasks_.push_back(task);
+  }
+
+  multi_picture_draw_.draw();
+
+  CompleteTasks(completed_tasks_);
+}
+
 void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "GpuRasterWorkerPool::ScheduleTasks");
 
   // Mark all task sets as pending.
   raster_pending_.set();
 
   unsigned priority = kRasterTaskPriorityBase;
 
   graph_.Reset();
 
@@ skipping 47 matching lines @@
   std::copy(new_raster_finished_tasks,
             new_raster_finished_tasks + kNumberOfTaskSets,
             raster_finished_tasks_);
 }
 
 void GpuRasterWorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "GpuRasterWorkerPool::CheckForCompletedTasks");
 
   task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                             &completed_tasks_);
-  for (Task::Vector::const_iterator it = completed_tasks_.begin();
-       it != completed_tasks_.end();
-       ++it) {
-    RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
+  CompleteTasks(completed_tasks_);
+  completed_tasks_.clear();

[vmiura, 2014/11/20 01:48:42]

Since CompleteTasks() calls completed_tasks_.clear(), this could be removed.

[ernstm, 2014/11/20 01:57:01]

Done.

+}
 
-    task->WillComplete();
-    task->CompleteOnOriginThread(this);
-    task->DidComplete();
+void GpuRasterWorkerPool::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> GpuRasterWorkerPool::AcquireBufferForRaster(
     const Resource* resource) {
   return make_scoped_ptr<RasterBuffer>(
       new RasterBufferImpl(resource_provider_,
                            resource,
                            &multi_picture_draw_,
@@ skipping 33 matching lines @@
 
   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