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

cc/resources/video_resource_updater.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/resources/video_resource_updater.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 54 matching lines @@
     case media::PIXEL_FORMAT_MT21:
     case media::PIXEL_FORMAT_UNKNOWN:
       break;
   }
   return VideoFrameExternalResources::NONE;
 }
 
 class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
  public:
   explicit SyncPointClientImpl(gpu::gles2::GLES2Interface* gl,
-                               uint32 sync_point)
-      : gl_(gl), sync_point_(sync_point) {}
+                               uint32 sync_point,
+                               const gpu::SyncToken& sync_token)
+      : gl_(gl), sync_point_(sync_point), sync_token_(sync_token) {}
   ~SyncPointClientImpl() override {}
   uint32 InsertSyncPoint() override {
     if (sync_point_)
       return sync_point_;
     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 WaitSyncPoint(uint32 sync_point,
+                     const gpu::SyncToken& sync_token) override {
+    if (sync_point || sync_token.HasData()) {
+      gl_->WaitSyncPointCHROMIUM(sync_point, sync_token.GetConstData());
+      if (sync_point_ || sync_token_.HasData()) {
+        gl_->WaitSyncPointCHROMIUM(sync_point_, sync_token_.GetConstData());
+        sync_point_ = 0;
+        sync_token_.Clear();
+      }
     }
   }
 
  private:
   gpu::gles2::GLES2Interface* gl_;
   uint32 sync_point_;
+  gpu::SyncToken sync_token_;
 };
 
 }  // namespace
 
 VideoResourceUpdater::PlaneResource::PlaneResource(
     unsigned int resource_id,
     const gfx::Size& resource_size,
     ResourceFormat resource_format,
     gpu::Mailbox mailbox)
     : resource_id(resource_id),
@@ skipping 268 matching lines @@
           memcpy(dst, src, bytes_per_row);
         }
         pixels = &upload_pixels_[0];
       }
 
       resource_provider_->CopyToResource(plane_resource.resource_id, pixels,
                                          resource_size_pixels);
       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, GL_TEXTURE_2D, 0, gpu::SyncToken()));
     external_resources.release_callbacks.push_back(
         base::Bind(&RecycleResource, AsWeakPtr(), plane_resource.resource_id));
   }
 
   external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
   return external_resources;
 }
 
 // static
 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
   // |video_frame|'s previous sync point using the current GL context.
   SyncPointClientImpl client(updater->context_provider_->ContextGL(),
-                             sync_point);
+                             sync_point, sync_token);
   video_frame->UpdateReleaseSyncPoint(&client);
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForHardwarePlanes");
   DCHECK(video_frame->HasTextures());
   if (!context_provider_)
     return VideoFrameExternalResources();
 
   VideoFrameExternalResources external_resources;
   external_resources.read_lock_fences_enabled = true;
 
   external_resources.type = ResourceTypeForVideoFrame(video_frame.get());
   if (external_resources.type == VideoFrameExternalResources::NONE) {
     DLOG(ERROR) << "Unsupported Texture format"
                 << media::VideoPixelFormatToString(video_frame->format());
     return external_resources;
   }
 
   const size_t num_planes = media::VideoFrame::NumPlanes(video_frame->format());
   for (size_t i = 0; i < num_planes; ++i) {
     const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(i);
     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(),
+                       mailbox_holder.sync_point, mailbox_holder.sync_token,
+                       video_frame->coded_size(),
                        video_frame->metadata()->IsTrue(
                            media::VideoFrameMetadata::ALLOW_OVERLAY)));
     external_resources.release_callbacks.push_back(
         base::Bind(&ReturnTexture, AsWeakPtr(), video_frame));
   }
   return external_resources;
 }
 
 // static
 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()) {
     // Resource was already deleted.
     return;
   }
 
   const ResourceList::iterator resource_it = std::find_if(
       updater->all_resources_.begin(), updater->all_resources_.end(),
       [resource_id](const PlaneResource& plane_resource) {
         return plane_resource.resource_id == resource_id;
       });
   if (resource_it == updater->all_resources_.end())
     return;
 
   ContextProvider* context_provider = updater->context_provider_;
-  if (context_provider && sync_point) {
-    context_provider->ContextGL()->WaitSyncPointCHROMIUM(sync_point);
+  if (context_provider && (sync_point || sync_token.HasData())) {
+    context_provider->ContextGL()->WaitSyncPointCHROMIUM(
+        sync_point, sync_token.GetConstData());
   }
 
   if (lost_resource) {
     resource_it->ref_count = 0;
     updater->DeleteResource(resource_it);
     return;
   }
 
   --resource_it->ref_count;
   DCHECK_GE(resource_it->ref_count, 0);
 }
 
 }  // namespace cc