Delay activation/draw on GPU tile work completion

cc/raster/raster_buffer_provider_unittest.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 "cc/raster/raster_buffer_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/cancelable_callback.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/base/unique_notifier.h"
 #include "cc/raster/bitmap_raster_buffer_provider.h"
 #include "cc/raster/gpu_raster_buffer_provider.h"
 #include "cc/raster/one_copy_raster_buffer_provider.h"
 #include "cc/raster/synchronous_task_graph_runner.h"
 #include "cc/raster/zero_copy_raster_buffer_provider.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/resource_pool.h"
@@ skipping 11 matching lines @@
 
 namespace cc {
 namespace {
 
 const size_t kMaxBytesPerCopyOperation = 1000U;
 const size_t kMaxStagingBuffers = 32U;
 
 enum RasterBufferProviderType {
   RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
   RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
+  RASTER_BUFFER_PROVIDER_TYPE_ASYNC_ONE_COPY,
   RASTER_BUFFER_PROVIDER_TYPE_GPU,
+  RASTER_BUFFER_PROVIDER_TYPE_ASYNC_GPU,
   RASTER_BUFFER_PROVIDER_TYPE_BITMAP
 };
 
 class TestRasterTaskCompletionHandler {
  public:
   virtual void OnRasterTaskCompleted(
       std::unique_ptr<RasterBuffer> raster_buffer,
       unsigned id,
       bool was_canceled) = 0;
 };
 
 class TestRasterTaskImpl : public TileTask {
  public:
   TestRasterTaskImpl(TestRasterTaskCompletionHandler* completion_handler,
-                     std::unique_ptr<ScopedResource> resource,
                      unsigned id,
                      std::unique_ptr<RasterBuffer> raster_buffer,
                      TileTask::Vector* dependencies)
       : TileTask(true, dependencies),
         completion_handler_(completion_handler),
-        resource_(std::move(resource)),
         id_(id),
         raster_buffer_(std::move(raster_buffer)),
         raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     // Don't use the image hijack canvas for these tests, as they have no image
     // decode controller.
     RasterSource::PlaybackSettings settings;
     settings.use_image_hijack_canvas = false;
 
     uint64_t new_content_id = 0;
     raster_buffer_->Playback(raster_source_.get(), gfx::Rect(1, 1),
                              gfx::Rect(1, 1), new_content_id, 1.f, settings);
   }
 
   // Overridden from TileTask:
   void OnTaskCompleted() override {
     completion_handler_->OnRasterTaskCompleted(std::move(raster_buffer_), id_,
                                                state().IsCanceled());
   }
 
  protected:
   ~TestRasterTaskImpl() override {}
 
  private:
   TestRasterTaskCompletionHandler* completion_handler_;
-  std::unique_ptr<ScopedResource> resource_;
   unsigned id_;
   std::unique_ptr<RasterBuffer> raster_buffer_;
   scoped_refptr<RasterSource> raster_source_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl);
 };
 
 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl {
  public:
   BlockingTestRasterTaskImpl(
       TestRasterTaskCompletionHandler* completion_handler,
-      std::unique_ptr<ScopedResource> resource,
       unsigned id,
       std::unique_ptr<RasterBuffer> raster_buffer,
       base::Lock* lock,
       TileTask::Vector* dependencies)
       : TestRasterTaskImpl(completion_handler,
-                           std::move(resource),
                            id,
                            std::move(raster_buffer),
                            dependencies),
         lock_(lock) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     base::AutoLock lock(*lock_);
     TestRasterTaskImpl::RunOnWorkerThread();
   }
@@ skipping 37 matching lines @@
             resource_provider_.get(), PlatformColor::BestTextureFormat());
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
         Create3dResourceProvider();
         raster_buffer_provider_ = base::MakeUnique<OneCopyRasterBufferProvider>(
             base::ThreadTaskRunnerHandle::Get().get(), context_provider_.get(),
             worker_context_provider_.get(), resource_provider_.get(),
             kMaxBytesPerCopyOperation, false, kMaxStagingBuffers,
             PlatformColor::BestTextureFormat(), false);
         break;
+      case RASTER_BUFFER_PROVIDER_TYPE_ASYNC_ONE_COPY:
+        Create3dResourceProvider();
+        raster_buffer_provider_ = base::MakeUnique<OneCopyRasterBufferProvider>(
+            base::ThreadTaskRunnerHandle::Get().get(), context_provider_.get(),
+            worker_context_provider_.get(), resource_provider_.get(),
+            kMaxBytesPerCopyOperation, false, kMaxStagingBuffers,
+            PlatformColor::BestTextureFormat(), true);
+        break;
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
         Create3dResourceProvider();
         raster_buffer_provider_ = base::MakeUnique<GpuRasterBufferProvider>(
             context_provider_.get(), worker_context_provider_.get(),
             resource_provider_.get(), false, 0, false);
         break;
+      case RASTER_BUFFER_PROVIDER_TYPE_ASYNC_GPU:
+        Create3dResourceProvider();
+        raster_buffer_provider_ = base::MakeUnique<GpuRasterBufferProvider>(
+            context_provider_.get(), worker_context_provider_.get(),
+            resource_provider_.get(), false, 0, true);
+        break;
       case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
         CreateSoftwareResourceProvider();
         raster_buffer_provider_ =
             BitmapRasterBufferProvider::Create(resource_provider_.get());
         break;
     }
 
     DCHECK(raster_buffer_provider_);
 
     tile_task_manager_ = TileTaskManagerImpl::Create(&task_graph_runner_);
   }
 
   void TearDown() override {
+    resources_.clear();
     tile_task_manager_->Shutdown();
     tile_task_manager_->CheckForCompletedTasks();
 
     raster_buffer_provider_->Shutdown();
   }
 
   void AllTileTasksFinished() {
     tile_task_manager_->CheckForCompletedTasks();
     base::MessageLoop::current()->QuitWhenIdle();
   }
@@ skipping 22 matching lines @@
     std::unique_ptr<ScopedResource> resource(
         ScopedResource::Create(resource_provider_.get()));
     resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                        RGBA_8888, gfx::ColorSpace());
 
     // The raster buffer has no tile ids associated with it for partial update,
     // so doesn't need to provide a valid dirty rect.
     std::unique_ptr<RasterBuffer> raster_buffer =
         raster_buffer_provider_->AcquireBufferForRaster(resource.get(), 0, 0);
     TileTask::Vector empty;
-    tasks_.push_back(new TestRasterTaskImpl(this, std::move(resource), id,
-                                            std::move(raster_buffer), &empty));
+    tasks_.push_back(
+        new TestRasterTaskImpl(this, id, std::move(raster_buffer), &empty));
+    resources_.push_back(std::move(resource));
   }
 
   void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); }
 
   void AppendBlockingTask(unsigned id, base::Lock* lock) {
     const gfx::Size size(1, 1);
 
     std::unique_ptr<ScopedResource> resource(
         ScopedResource::Create(resource_provider_.get()));
     resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                        RGBA_8888, gfx::ColorSpace());
 
     std::unique_ptr<RasterBuffer> raster_buffer =
         raster_buffer_provider_->AcquireBufferForRaster(resource.get(), 0, 0);
     TileTask::Vector empty;
     tasks_.push_back(new BlockingTestRasterTaskImpl(
-        this, std::move(resource), id, std::move(raster_buffer), lock, &empty));
+        this, id, std::move(raster_buffer), lock, &empty));
+    resources_.push_back(std::move(resource));
   }
 
   const std::vector<RasterTaskResult>& completed_tasks() const {
     return completed_tasks_;
   }
 
   void LoseContext(ContextProvider* context_provider) {
     if (!context_provider)
       return;
     context_provider->ContextGL()->LoseContextCHROMIUM(
@@ skipping 41 matching lines @@
   std::unique_ptr<RasterBufferProvider> raster_buffer_provider_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   TestSharedBitmapManager shared_bitmap_manager_;
   SynchronousTaskGraphRunner task_graph_runner_;
   base::CancelableClosure timeout_;
   UniqueNotifier all_tile_tasks_finished_;
   int timeout_seconds_;
   bool timed_out_;
   RasterTaskVector tasks_;
   std::vector<RasterTaskResult> completed_tasks_;
+  std::vector<std::unique_ptr<ScopedResource>> resources_;
   TaskGraph graph_;
 };
 
 TEST_P(RasterBufferProviderTest, Basic) {
   AppendTask(0u);
   AppendTask(1u);
   ScheduleTasks();
 
   RunMessageLoopUntilAllTasksHaveCompleted();
 
@@ skipping 49 matching lines @@
   AppendTask(1u);
   ScheduleTasks();
 
   RunMessageLoopUntilAllTasksHaveCompleted();
 
   ASSERT_EQ(2u, completed_tasks().size());
   EXPECT_FALSE(completed_tasks()[0].canceled);
   EXPECT_FALSE(completed_tasks()[1].canceled);
 }
 
-INSTANTIATE_TEST_CASE_P(RasterBufferProviderTests,
-                        RasterBufferProviderTest,
-                        ::testing::Values(RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
-                                          RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
-                                          RASTER_BUFFER_PROVIDER_TYPE_GPU,
-                                          RASTER_BUFFER_PROVIDER_TYPE_BITMAP));
+TEST_P(RasterBufferProviderTest, ReadyToDrawCallback) {
+  AppendTask(0u);
+  ScheduleTasks();
+  RunMessageLoopUntilAllTasksHaveCompleted();
+
+  ResourceProvider::ResourceIdArray array;
+  for (const auto& resource : resources_) {
+    array.push_back(resource->id());
+  }
+  base::RunLoop run_loop;
+  uint64_t callback_id = raster_buffer_provider_->SetReadyToDrawCallback(
+      array,
+      base::Bind([](base::RunLoop* run_loop) { run_loop->Quit(); }, &run_loop),
+      0);
+
+  if (GetParam() == RASTER_BUFFER_PROVIDER_TYPE_ASYNC_GPU ||
+      GetParam() == RASTER_BUFFER_PROVIDER_TYPE_ASYNC_ONE_COPY)
+    EXPECT_TRUE(callback_id);
+
+  if (!callback_id)
+    return;
+
+  run_loop.Run();
+}
+
+TEST_P(RasterBufferProviderTest, ReadyToDrawCallbackNoDuplicate) {
+  AppendTask(0u);
+  ScheduleTasks();
+  RunMessageLoopUntilAllTasksHaveCompleted();
+
+  ResourceProvider::ResourceIdArray array;
+  for (const auto& resource : resources_) {
+    array.push_back(resource->id());
+  }
+
+  uint64_t callback_id = raster_buffer_provider_->SetReadyToDrawCallback(
+      array, base::Bind([]() {}), 0);
+
+  // Calling SetReadyToDrawCallback a second time for the same resources
+  // should return the same callback ID.
+  uint64_t callback_id_2 = raster_buffer_provider_->SetReadyToDrawCallback(
+      array, base::Bind([]() {}), 0);
+
+  EXPECT_EQ(callback_id, callback_id_2);
+
+  if (GetParam() == RASTER_BUFFER_PROVIDER_TYPE_ASYNC_GPU ||
+      GetParam() == RASTER_BUFFER_PROVIDER_TYPE_ASYNC_ONE_COPY)
+    EXPECT_TRUE(callback_id);
+}
+
+INSTANTIATE_TEST_CASE_P(
+    RasterBufferProviderTests,
+    RasterBufferProviderTest,
+    ::testing::Values(RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
+                      RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
+                      RASTER_BUFFER_PROVIDER_TYPE_ASYNC_ONE_COPY,
+                      RASTER_BUFFER_PROVIDER_TYPE_GPU,
+                      RASTER_BUFFER_PROVIDER_TYPE_ASYNC_GPU,
+                      RASTER_BUFFER_PROVIDER_TYPE_BITMAP));
 
 }  // namespace
 }  // namespace cc