Modified old wait sync point functions to also accept new sync tokens.

cc/resources/video_resource_updater.cc

Index: cc/resources/video_resource_updater.cc
diff --git a/cc/resources/video_resource_updater.cc b/cc/resources/video_resource_updater.cc
index b2f8629459f87bc5d8a65dba0787dd7460391948..44a7ac2d2574822381ff70ac81333404708e0913 100644
--- a/cc/resources/video_resource_updater.cc
+++ b/cc/resources/video_resource_updater.cc
@@ -69,30 +69,33 @@ VideoFrameExternalResources::ResourceType ResourceTypeForVideoFrame(
   return VideoFrameExternalResources::NONE;
 }
 
-class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
+class SyncTokenClientImpl : public media::VideoFrame::SyncTokenClient {
  public:
-  explicit SyncPointClientImpl(gpu::gles2::GLES2Interface* gl,
-                               uint32 sync_point)
-      : gl_(gl), sync_point_(sync_point) {}
-  ~SyncPointClientImpl() override {}
+  explicit SyncTokenClientImpl(gpu::gles2::GLES2Interface* gl,

[dcheng, 2015/11/03 07:39:29]

Nit: no explicit, it takes multiple arguments.

[David Yen, 2015/11/03 18:09:27]

Done.

+                               const gpu::SyncToken& sync_token)
+      : gl_(gl), sync_token_(sync_token) {}
+  ~SyncTokenClientImpl() override {}
   uint32 InsertSyncPoint() override {
-    if (sync_point_)
-      return sync_point_;
+    if (sync_token_.HasData()) {
+      DCHECK(sync_token_.namespace_id() ==

[dcheng, 2015/11/03 07:39:29]

Nit: DCHECK_EQ(gpu::CommandBufferNamespace::OLD_SYNC_POINTS,
sync_token_.namespace_id());

[David Yen, 2015/11/03 18:09:28]

Done.

+             gpu::CommandBufferNamespace::OLD_SYNC_POINTS);
+      return static_cast<uint32>(sync_token_.release_count());

[dcheng, 2015/11/03 07:39:29]

Out of curiosity, why isn't release_count() just a uint32_t to avoid these
casts?

[David Yen, 2015/11/03 18:09:27]

The new sync tokens need 64 bit releases to avoid overflow. The old sync points
are 32 bit, this CL is temporarily folding the old sync points into the new sync
tokens before removing the old code so I am just using 32 bits of the release
counter.

[David Yen, 2015/11/03 18:18:36]

In case it is unclear, this function will eventually be turned into something
like "void InsertSyncToken(gpu::SyncToken* sync_token)" instead of using the old
sync points. This can happen incrementally and we wouldn't need to change any
call sites which do the wait.

+    }
     return gl_->InsertSyncPointCHROMIUM();
   }
-  void WaitSyncPoint(uint32 sync_point) override {
-    if (!sync_point)
-      return;
-    gl_->WaitSyncPointCHROMIUM(sync_point);
-    if (sync_point_) {
-      gl_->WaitSyncPointCHROMIUM(sync_point_);
-      sync_point_ = 0;
+  void WaitSyncToken(const gpu::SyncToken& sync_token) override {
+    if (sync_token.HasData()) {
+      gl_->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
+      if (sync_token_.HasData()) {
+        gl_->WaitSyncTokenCHROMIUM(sync_token_.GetConstData());
+        sync_token_.Clear();
+      }
     }
   }
 
  private:
   gpu::gles2::GLES2Interface* gl_;
-  uint32 sync_point_;
+  gpu::SyncToken sync_token_;
 };
 
 }  // namespace
@@ -381,8 +384,8 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
       SetPlaneResourceUniqueId(video_frame.get(), i, &plane_resource);
     }
 
-    external_resources.mailboxes.push_back(
-        TextureMailbox(plane_resource.mailbox, GL_TEXTURE_2D, 0));
+    external_resources.mailboxes.push_back(TextureMailbox(
+        plane_resource.mailbox, gpu::SyncToken(), GL_TEXTURE_2D));
     external_resources.release_callbacks.push_back(
         base::Bind(&RecycleResource, AsWeakPtr(), plane_resource.resource_id));
   }
@@ -395,19 +398,19 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
 void VideoResourceUpdater::ReturnTexture(
     base::WeakPtr<VideoResourceUpdater> updater,
     const scoped_refptr<media::VideoFrame>& video_frame,
-    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     bool lost_resource,
     BlockingTaskRunner* main_thread_task_runner) {
   // TODO(dshwang) this case should be forwarded to the decoder as lost
   // resource.
   if (lost_resource || !updater.get())
     return;
-  // Update the release sync point in |video_frame| with |sync_point|
-  // returned by the compositor and emit a WaitSyncPointCHROMIUM on
+  // Update the release sync point in |video_frame| with |sync_token|
+  // returned by the compositor and emit a WaitSyncTokenCHROMIUM on
   // |video_frame|'s previous sync point using the current GL context.
-  SyncPointClientImpl client(updater->context_provider_->ContextGL(),
-                             sync_point);
-  video_frame->UpdateReleaseSyncPoint(&client);
+  SyncTokenClientImpl client(updater->context_provider_->ContextGL(),
+                             sync_token);
+  video_frame->UpdateReleaseSyncToken(&client);
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
@@ -433,8 +436,8 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
     if (mailbox_holder.mailbox.IsZero())
       break;
     external_resources.mailboxes.push_back(
-        TextureMailbox(mailbox_holder.mailbox, mailbox_holder.texture_target,
-                       mailbox_holder.sync_point, video_frame->coded_size(),
+        TextureMailbox(mailbox_holder.mailbox, mailbox_holder.sync_token,
+                       mailbox_holder.texture_target, video_frame->coded_size(),
                        video_frame->metadata()->IsTrue(
                            media::VideoFrameMetadata::ALLOW_OVERLAY)));
     external_resources.release_callbacks.push_back(
@@ -447,7 +450,7 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     ResourceId resource_id,
-    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     bool lost_resource,
     BlockingTaskRunner* main_thread_task_runner) {
   if (!updater.get()) {
@@ -464,8 +467,9 @@ void VideoResourceUpdater::RecycleResource(
     return;
 
   ContextProvider* context_provider = updater->context_provider_;
-  if (context_provider && sync_point) {
-    context_provider->ContextGL()->WaitSyncPointCHROMIUM(sync_point);
+  if (context_provider && sync_token.HasData()) {
+    context_provider->ContextGL()->WaitSyncTokenCHROMIUM(
+        sync_token.GetConstData());
   }
 
   if (lost_resource) {