cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread().

cc/raster/raster_buffer_provider_perftest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 111 matching lines @@
 static const int kTimeCheckInterval = 10;
 
 class PerfImageDecodeTaskImpl : public TileTask {
  public:
   PerfImageDecodeTaskImpl() : TileTask(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;
-  }
+  void OnTaskCompleted() override { state().Reset(); }
 
  protected:
   ~PerfImageDecodeTaskImpl() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl);
 };
 
+class PerfRasterBufferProviderHelper {
+ public:
+  virtual std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
+      const Resource* resource,
+      uint64_t resource_content_id,
+      uint64_t previous_content_id) = 0;
+  virtual void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) = 0;
+};
+
 class PerfRasterTaskImpl : public TileTask {
  public:
-  PerfRasterTaskImpl(std::unique_ptr<ScopedResource> resource,
+  PerfRasterTaskImpl(PerfRasterBufferProviderHelper* helper,
+                     std::unique_ptr<ScopedResource> resource,
+                     std::unique_ptr<RasterBuffer> raster_buffer,
                      TileTask::Vector* dependencies)
-      : TileTask(true, dependencies), resource_(std::move(resource)) {}
+      : TileTask(true, dependencies),
+        helper_(helper),
+        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 OnTaskCompleted() override {
+    if (helper_)
+      helper_->ReleaseBufferForRaster(std::move(raster_buffer_));
 
-  void Reset() {
     state().Reset();
-    did_complete_ = false;
   }
 
  protected:
   ~PerfRasterTaskImpl() override {}
 
  private:
+  PerfRasterBufferProviderHelper* helper_;
   std::unique_ptr<ScopedResource> resource_;
   std::unique_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl);
 };
 
 class RasterBufferProviderPerfTestBase {
  public:
   typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
 
   RasterBufferProviderPerfTestBase()
       : context_provider_(make_scoped_refptr(new PerfContextProvider)),
         task_runner_(new base::TestSimpleTaskRunner),
         task_graph_runner_(new SynchronousTaskGraphRunner),
         timer_(kWarmupRuns,
                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
                kTimeCheckInterval) {}
 
   void CreateImageDecodeTasks(unsigned num_image_decode_tasks,
                               TileTask::Vector* image_decode_tasks) {
     for (unsigned i = 0; i < num_image_decode_tasks; ++i)
       image_decode_tasks->push_back(new PerfImageDecodeTaskImpl);
   }
 
-  void CreateRasterTasks(unsigned num_raster_tasks,
+  void CreateRasterTasks(PerfRasterBufferProviderHelper* helper,
+                         unsigned num_raster_tasks,
                          const TileTask::Vector& image_decode_tasks,
                          RasterTaskVector* raster_tasks) {
     const gfx::Size size(1, 1);
 
     for (unsigned i = 0; i < num_raster_tasks; ++i) {
       std::unique_ptr<ScopedResource> resource(
           ScopedResource::Create(resource_provider_.get()));
       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 (helper)
+        raster_buffer = helper->AcquireBufferForRaster(resource.get(), 0, 0);
       TileTask::Vector dependencies = image_decode_tasks;
       raster_tasks->push_back(
-          new PerfRasterTaskImpl(std::move(resource), &dependencies));
+          new PerfRasterTaskImpl(helper, std::move(resource),
+                                 std::move(raster_buffer), &dependencies));
     }
   }
 
   void BuildTileTaskGraph(TaskGraph* graph,
                           const RasterTaskVector& raster_tasks) {
     uint16_t priority = 0;
 
     for (auto& raster_task : raster_tasks) {
       priority++;
 
@@ skipping 25 matching lines @@
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   std::unique_ptr<SynchronousTaskGraphRunner> task_graph_runner_;
   LapTimer timer_;
 };
 
 class RasterBufferProviderPerfTest
     : public RasterBufferProviderPerfTestBase,
+      public PerfRasterBufferProviderHelper,
       public testing::TestWithParam<RasterBufferProviderType> {
  public:
   // Overridden from testing::Test:
   void SetUp() override {
     std::unique_ptr<RasterBufferProvider> raster_buffer_provider;
     switch (GetParam()) {
       case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
         Create3dOutputSurfaceAndResourceProvider();
         raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
             resource_provider_.get(), PlatformColor::BestTextureFormat());
@@ skipping 21 matching lines @@
     DCHECK(raster_buffer_provider);
 
     tile_task_manager_ = TileTaskManagerImpl::Create(
         std::move(raster_buffer_provider), task_graph_runner_.get());
   }
   void TearDown() override {
     tile_task_manager_->Shutdown();
     tile_task_manager_->CheckForCompletedTasks();
   }
 
+  // Overridden from PerfRasterBufferProviderHelper:
+  std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
+      const Resource* resource,
+      uint64_t resource_content_id,
+      uint64_t previous_content_id) override {
+    return tile_task_manager_->GetRasterBufferProvider()
+        ->AcquireBufferForRaster(resource, resource_content_id,
+                                 previous_content_id);
+  }
+  void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {
+    tile_task_manager_->GetRasterBufferProvider()->ReleaseBufferForRaster(
+        std::move(buffer));
+  }
+
   void RunMessageLoopUntilAllTasksHaveCompleted() {
     task_graph_runner_->RunUntilIdle();
     task_runner_->RunUntilIdle();
   }
 
   void RunScheduleTasksTest(const std::string& test_name,
                             unsigned num_raster_tasks,
                             unsigned num_image_decode_tasks) {
     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(this, num_raster_tasks, image_decode_tasks,
+                      &raster_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
 
     timer_.Reset();
     do {
       graph.Reset();
       BuildTileTaskGraph(&graph, raster_tasks);
       tile_task_manager_->ScheduleTasks(&graph);
       tile_task_manager_->CheckForCompletedTasks();
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     TaskGraph empty;
     tile_task_manager_->ScheduleTasks(&empty);
     RunMessageLoopUntilAllTasksHaveCompleted();
 
     perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name,
                            timer_.LapsPerSecond(), "runs/s", true);
   }
 
   void RunScheduleAlternateTasksTest(const std::string& test_name,
                                      unsigned num_raster_tasks,
                                      unsigned num_image_decode_tasks) {
     const size_t kNumVersions = 2;
     TileTask::Vector image_decode_tasks[kNumVersions];
     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],
+      CreateRasterTasks(this, num_raster_tasks, image_decode_tasks[i],
                         &raster_tasks[i]);
     }
 
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
 
     size_t count = 0;
     timer_.Reset();
     do {
       graph.Reset();
@@ skipping 11 matching lines @@
     perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(),
                            test_name, timer_.LapsPerSecond(), "runs/s", true);
   }
 
   void RunScheduleAndExecuteTasksTest(const std::string& test_name,
                                       unsigned num_raster_tasks,
                                       unsigned num_image_decode_tasks) {
     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(this, num_raster_tasks, image_decode_tasks,
+                      &raster_tasks);
 
     // Avoid unnecessary heap allocations by reusing the same graph.
     TaskGraph graph;
 
     timer_.Reset();
     do {
       graph.Reset();
       BuildTileTaskGraph(&graph, raster_tasks);
       tile_task_manager_->ScheduleTasks(&graph);
       RunMessageLoopUntilAllTasksHaveCompleted();
@@ skipping 89 matching lines @@
     resource_provider_ =
         FakeResourceProvider::Create(output_surface_.get(), nullptr);
   }
 
   void RunBuildTileTaskGraphTest(const std::string& test_name,
                                  unsigned num_raster_tasks,
                                  unsigned num_image_decode_tasks) {
     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;
 
     timer_.Reset();
     do {
       graph.Reset();
       BuildTileTaskGraph(&graph, raster_tasks);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("build_raster_task_graph", "", test_name,
                            timer_.LapsPerSecond(), "runs/s", true);
   }
 };
 
 TEST_F(RasterBufferProviderCommonPerfTest, BuildTileTaskGraph) {
   RunBuildTileTaskGraphTest("1_0", 1, 0);
   RunBuildTileTaskGraphTest("32_0", 32, 0);
   RunBuildTileTaskGraphTest("1_1", 1, 1);
   RunBuildTileTaskGraphTest("32_1", 32, 1);
   RunBuildTileTaskGraphTest("1_4", 1, 4);
   RunBuildTileTaskGraphTest("32_4", 32, 4);
 }
 
 }  // namespace
 }  // namespace cc