cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread().

cc/raster/raster_buffer_provider_perftest.cc

Index: cc/raster/raster_buffer_provider_perftest.cc
diff --git a/cc/raster/raster_buffer_provider_perftest.cc b/cc/raster/raster_buffer_provider_perftest.cc
index 662a24a595839036942293ed686e0024410e6dd5..fdfd8ecb9aef2d9664ea706565a5379427f08cfe 100644
--- a/cc/raster/raster_buffer_provider_perftest.cc
+++ b/cc/raster/raster_buffer_provider_perftest.cc
@@ -123,22 +123,11 @@ static const int kTimeCheckInterval = 10;
 
 class PerfImageDecodeTaskImpl : public TileTask {
  public:
-  PerfImageDecodeTaskImpl() : TileTask(true) {}
+  PerfImageDecodeTaskImpl() : TileTask(TileTask::Type::IMAGE_DECODE, true) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {}
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(RasterBufferProvider* provider) override {}
-  void CompleteOnOriginThread(RasterBufferProvider* provider) override {
-    Reset();
-  }
-
-  void Reset() {
-    state().Reset();
-    did_complete_ = false;
-  }
-
  protected:
   ~PerfImageDecodeTaskImpl() override {}
 
@@ -149,31 +138,21 @@ class PerfImageDecodeTaskImpl : public TileTask {
 class PerfRasterTaskImpl : public TileTask {
  public:
   PerfRasterTaskImpl(std::unique_ptr<ScopedResource> resource,
+                     std::unique_ptr<RasterBuffer> raster_buffer,
                      TileTask::Vector* dependencies)
-      : TileTask(true, dependencies), resource_(std::move(resource)) {}
+      : TileTask(TileTask::Type::RASTER, true, dependencies),
+        resource_(std::move(resource)),
+        raster_buffer_(std::move(raster_buffer)) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {}
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(RasterBufferProvider* provider) override {
-    // No tile ids are given to support partial updates.
-    raster_buffer_ = provider->AcquireBufferForRaster(resource_.get(), 0, 0);
-  }
-  void CompleteOnOriginThread(RasterBufferProvider* provider) override {
-    provider->ReleaseBufferForRaster(std::move(raster_buffer_));
-    Reset();
-  }
-
-  void Reset() {
-    state().Reset();
-    did_complete_ = false;
-  }
-
  protected:
   ~PerfRasterTaskImpl() override {}
 
  private:
+  friend class RasterBufferProviderPerfTest;
+
   std::unique_ptr<ScopedResource> resource_;
   std::unique_ptr<RasterBuffer> raster_buffer_;
 
@@ -200,7 +179,8 @@ class RasterBufferProviderPerfTestBase {
       image_decode_tasks->push_back(new PerfImageDecodeTaskImpl);
   }
 
-  void CreateRasterTasks(unsigned num_raster_tasks,
+  void CreateRasterTasks(TileTaskManager* tile_task_manager,
+                         unsigned num_raster_tasks,
                          const TileTask::Vector& image_decode_tasks,
                          RasterTaskVector* raster_tasks) {
     const gfx::Size size(1, 1);
@@ -211,9 +191,15 @@ class RasterBufferProviderPerfTestBase {
       resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                          RGBA_8888);
 
+      // No tile ids are given to support partial updates.
+      std::unique_ptr<RasterBuffer> raster_buffer;
+      if (tile_task_manager) {
+        raster_buffer = tile_task_manager->GetRasterBufferProvider()
+                            ->AcquireBufferForRaster(resource.get(), 0, 0);
+      }
       TileTask::Vector dependencies = image_decode_tasks;
-      raster_tasks->push_back(
-          new PerfRasterTaskImpl(std::move(resource), &dependencies));
+      raster_tasks->push_back(new PerfRasterTaskImpl(
+          std::move(resource), std::move(raster_buffer), &dependencies));
     }
   }
 
@@ -297,7 +283,7 @@ class RasterBufferProviderPerfTest
   }
   void TearDown() override {
     tile_task_manager_->Shutdown();
-    tile_task_manager_->CheckForCompletedTasks();
+    CheckForCompletedTasks();
   }
 
   void RunMessageLoopUntilAllTasksHaveCompleted() {
@@ -311,7 +297,8 @@ class RasterBufferProviderPerfTest
     TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
-    CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
+    CreateRasterTasks(tile_task_manager_.get(), num_raster_tasks,
+                      image_decode_tasks, &raster_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
@@ -321,7 +308,7 @@ class RasterBufferProviderPerfTest
       graph.Reset();
       BuildTileTaskGraph(&graph, raster_tasks);
       tile_task_manager_->ScheduleTasks(&graph);
-      tile_task_manager_->CheckForCompletedTasks();
+      CheckForCompletedTasks();
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
@@ -341,8 +328,8 @@ class RasterBufferProviderPerfTest
     RasterTaskVector raster_tasks[kNumVersions];
     for (size_t i = 0; i < kNumVersions; ++i) {
       CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);
-      CreateRasterTasks(num_raster_tasks, image_decode_tasks[i],
-                        &raster_tasks[i]);
+      CreateRasterTasks(tile_task_manager_.get(), num_raster_tasks,
+                        image_decode_tasks[i], &raster_tasks[i]);
     }
 
     // Avoid unnecessary heap allocations by reusing the same graph.
@@ -354,7 +341,7 @@ class RasterBufferProviderPerfTest
       graph.Reset();
       BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]);
       tile_task_manager_->ScheduleTasks(&graph);
-      tile_task_manager_->CheckForCompletedTasks();
+      CheckForCompletedTasks();
       ++count;
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
@@ -373,7 +360,8 @@ class RasterBufferProviderPerfTest
     TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
-    CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
+    CreateRasterTasks(tile_task_manager_.get(), num_raster_tasks,
+                      image_decode_tasks, &raster_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
@@ -426,6 +414,36 @@ class RasterBufferProviderPerfTest
     return std::string();
   }
 
+  void CheckForCompletedTasks() {
+    Task::Vector completed_tasks;
+    tile_task_manager_->CollectCompletedTasks(&completed_tasks);
+
+    for (auto task : completed_tasks) {
+      TileTask* tile_task = static_cast<TileTask*>(task.get());
+      switch (tile_task->type()) {
+        case TileTask::Type::RASTER:
+          OnRasterTaskCompleted(tile_task);
+          break;
+        case TileTask::Type::IMAGE_DECODE:
+          break;
+        default:
+          NOTREACHED();
+      }
+
+      // Instead of calling DidComplete(), call Reset() as same task would be
+      // reused as if new.
+      task->state().Reset();
+    }
+
+    completed_tasks.clear();
+  }
+
+  void OnRasterTaskCompleted(TileTask* task) {
+    PerfRasterTaskImpl* raster_task = static_cast<PerfRasterTaskImpl*>(task);
+    tile_task_manager_->GetRasterBufferProvider()->ReleaseBufferForRaster(
+        std::move(raster_task->raster_buffer_));
+  }
+
   std::unique_ptr<TileTaskManager> tile_task_manager_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   TestSharedBitmapManager shared_bitmap_manager_;
@@ -483,7 +501,8 @@ class RasterBufferProviderCommonPerfTest
     TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
-    CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
+    CreateRasterTasks(nullptr, num_raster_tasks, image_decode_tasks,
+                      &raster_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;