Remove GpuVideoAcceleratorFactories::SignalSyncToken

The only calller was GpuMemoryBufferVideoFramePool, but doesn't need to
any more as crbug.com/819914 was fixed.

Bug: 819914
Change-Id: Ife76f3a9ed7e287f94ea0db97f0c27a6179f4a3e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1674408
Commit-Queue: Antoine Labour <piman@chromium.org>
Auto-Submit: Antoine Labour <piman@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#672203}

content/browser/media/android/browser_gpu_video_accelerator_factories.cc

@@ -117,10 +117,6 @@ BrowserGpuVideoAcceleratorFactories::CreateVideoEncodeAccelerator() {
   return nullptr;
 }
 
-void BrowserGpuVideoAcceleratorFactories::SignalSyncToken(
-    const gpu::SyncToken& sync_token,
-    base::OnceClosure callback) {}
-
 std::unique_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuVideoAcceleratorFactories::CreateGpuMemoryBuffer(
     const gfx::Size& size,

content/browser/media/android/browser_gpu_video_accelerator_factories.h

@@ -33,8 +33,6 @@ class BrowserGpuVideoAcceleratorFactories
       const media::RequestOverlayInfoCB& request_overlay_info_cb) override;
   std::unique_ptr<media::VideoEncodeAccelerator> CreateVideoEncodeAccelerator()
       override;
-  void SignalSyncToken(const gpu::SyncToken& sync_token,
-                       base::OnceClosure callback) override;
   std::unique_ptr<gfx::GpuMemoryBuffer> CreateGpuMemoryBuffer(
       const gfx::Size& size,
       gfx::BufferFormat format,

content/renderer/media/gpu/gpu_video_accelerator_factories_impl.cc

@@ -258,17 +258,6 @@ GpuVideoAcceleratorFactoriesImpl::CreateVideoEncodeAccelerator() {
                               .video_encode_accelerator_supported_profiles));
 }
 
-void GpuVideoAcceleratorFactoriesImpl::SignalSyncToken(
-    const gpu::SyncToken& sync_token,
-    base::OnceClosure callback) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  if (CheckContextLost())
-    return;
-
-  context_provider_->ContextSupport()->SignalSyncToken(sync_token,
-                                                       std::move(callback));
-}
-
 std::unique_ptr<gfx::GpuMemoryBuffer>
 GpuVideoAcceleratorFactoriesImpl::CreateGpuMemoryBuffer(
     const gfx::Size& size,

content/renderer/media/gpu/gpu_video_accelerator_factories_impl.h

@@ -79,8 +79,6 @@ class CONTENT_EXPORT GpuVideoAcceleratorFactoriesImpl
       const media::VideoDecoderConfig& config) override;
   std::unique_ptr<media::VideoEncodeAccelerator> CreateVideoEncodeAccelerator()
       override;
-  void SignalSyncToken(const gpu::SyncToken& sync_token,
-                       base::OnceClosure callback) override;
 
   std::unique_ptr<gfx::GpuMemoryBuffer> CreateGpuMemoryBuffer(
       const gfx::Size& size,

media/video/gpu_memory_buffer_video_frame_pool.cc

@@ -118,6 +118,10 @@ class GpuMemoryBufferVideoFramePool::PoolImpl
 
     const gfx::Size size;
     PlaneResource plane_resources[VideoFrame::kMaxPlanes];
+    // The sync token used to recycle or destroy the resources. It is set when
+    // the resources are returned from the VideoFrame (via
+    // MailboxHoldersReleased).
+    gpu::SyncToken sync_token;
 
    private:
     bool is_used_ = true;
@@ -184,11 +188,6 @@ class GpuMemoryBufferVideoFramePool::PoolImpl
   void MailboxHoldersReleased(FrameResources* frame_resources,
                               const gpu::SyncToken& sync_token);
 
-  // Callback called when a VideoFrame generated with GetFrameResources has
-  // outlived its release SyncToken.
-  // This must be called on the thread where |media_task_runner_| is current.
-  void MailboxHoldersWaited(FrameResources* frame_resources);
-
   // Delete resources. This has to be called on the thread where |task_runner|
   // is current.
   static void DeleteFrameResources(
@@ -934,8 +933,8 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::
                                  gpu_factories_->GpuMemoryBufferManager(),
                                  video_frame->ColorSpace(), usage);
     } else if (!plane_resource.mailbox.IsZero()) {
-      // The sync token was waited on the client side before reuse.
-      sii->UpdateSharedImage(gpu::SyncToken(), plane_resource.mailbox);
+      sii->UpdateSharedImage(frame_resources->sync_token,
+                             plane_resource.mailbox);
     }
     mailbox_holders[i] = gpu::MailboxHolder(plane_resource.mailbox,
                                             gpu::SyncToken(), texture_target);
@@ -959,7 +958,7 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::
 
   if (!frame) {
     frame_resources->MarkUnused(tick_clock_->NowTicks());
-    MailboxHoldersReleased(frame_resources, gpu::SyncToken());
+    MailboxHoldersReleased(frame_resources, sync_token);
     CompleteCopyRequestAndMaybeStartNextCopy(std::move(video_frame));
     return;
   }
@@ -1110,9 +1109,8 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::DeleteFrameResources(
 
   for (PlaneResource& plane_resource : frame_resources->plane_resources) {
     if (!plane_resource.mailbox.IsZero()) {
-      // The sync token was already waited on the client side in
-      // MailboxHoldersReleased.
-      sii->DestroySharedImage(gpu::SyncToken(), plane_resource.mailbox);
+      sii->DestroySharedImage(frame_resources->sync_token,
+                              plane_resource.mailbox);
     }
   }
 }
@@ -1128,27 +1126,7 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::MailboxHoldersReleased(
                                   frame_resources, release_sync_token));
     return;
   }
-
-  // TODO(sandersd): Remove once https://crbug.com/819914 is fixed. Correct
-  // clients must wait for READ_LOCK_FENCES_ENABLED frames to be read before
-  // returning the frame, so waiting on the sync token should be a no-op.
-  //
-  // If the context is lost, SignalSyncToken() drops its callbacks. Using a
-  // ScopedClosureRunner ensures MailboxHoldersWaited() is called if that
-  // happens.
-  std::unique_ptr<base::ScopedClosureRunner> waited_cb =
-      std::make_unique<base::ScopedClosureRunner>(base::BindOnce(
-          &GpuMemoryBufferVideoFramePool::PoolImpl::MailboxHoldersWaited, this,
-          frame_resources));
-  gpu_factories_->SignalSyncToken(
-      release_sync_token,
-      base::BindOnce(&base::ScopedClosureRunner::RunAndReset,
-                     std::move(waited_cb)));
-}
-
-void GpuMemoryBufferVideoFramePool::PoolImpl::MailboxHoldersWaited(
-    FrameResources* frame_resources) {
-  DCHECK(media_task_runner_->BelongsToCurrentThread());
+  frame_resources->sync_token = release_sync_token;
 
   if (in_shutdown_) {
     DeleteFrameResources(gpu_factories_, frame_resources);

media/video/gpu_memory_buffer_video_frame_pool_unittest.cc

@@ -35,8 +35,6 @@ class GpuMemoryBufferVideoFramePoolTest : public ::testing::Test {
     media_task_runner_handle_.reset(
         new base::ThreadTaskRunnerHandle(media_task_runner_));
     mock_gpu_factories_.reset(new MockGpuVideoAcceleratorFactories(sii_.get()));
-    EXPECT_CALL(*mock_gpu_factories_.get(), SignalSyncToken(_, _))
-        .Times(AtLeast(0));
     gpu_memory_buffer_pool_.reset(new GpuMemoryBufferVideoFramePool(
         media_task_runner_, copy_task_runner_.get(),
         mock_gpu_factories_.get()));

media/video/gpu_video_accelerator_factories.h

@@ -37,7 +37,6 @@ class Size;
 namespace gpu {
 class GpuMemoryBufferManager;
 class SharedImageInterface;
-struct SyncToken;
 }
 
 namespace viz {
@@ -98,9 +97,6 @@ class MEDIA_EXPORT GpuVideoAcceleratorFactories {
   virtual std::unique_ptr<VideoEncodeAccelerator>
   CreateVideoEncodeAccelerator() = 0;
 
-  virtual void SignalSyncToken(const gpu::SyncToken& sync_token,
-                               base::OnceClosure callback) = 0;
-
   virtual std::unique_ptr<gfx::GpuMemoryBuffer> CreateGpuMemoryBuffer(
       const gfx::Size& size,
       gfx::BufferFormat format,

media/video/mock_gpu_video_accelerator_factories.h

@@ -47,9 +47,6 @@ class MockGpuVideoAcceleratorFactories : public GpuVideoAcceleratorFactories {
   // framework does not want. Trampoline it.
   MOCK_METHOD0(DoCreateVideoEncodeAccelerator, VideoEncodeAccelerator*());
 
-  MOCK_METHOD2(SignalSyncToken,
-               void(const gpu::SyncToken& sync_token,
-                    base::OnceClosure callback));
   MOCK_METHOD0(GetTaskRunner, scoped_refptr<base::SingleThreadTaskRunner>());
   MOCK_METHOD0(GetVideoEncodeAcceleratorSupportedProfiles,
                VideoEncodeAccelerator::SupportedProfiles());