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

media/video/gpu_memory_buffer_video_frame_pool.cc

 // Copyright 2015 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 "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include <algorithm>
@@ skipping 106 matching lines @@
   // Get the resources needed for a frame out of the pool, or create them if
   // necessary.
   // This also drops the LRU resources that can't be reuse for this frame.
   FrameResources* GetOrCreateFrameResources(const gfx::Size& size,
                                             VideoPixelFormat format);
 
   // Callback called when a VideoFrame generated with GetFrameResources is no
   // longer referenced.
   // This could be called by any thread.
   void MailboxHoldersReleased(FrameResources* frame_resources,
-                              uint32 sync_point);
+                              const gpu::SyncToken& sync_token);
 
   // Return frame resources to the pool. This has to be called on the thread
   // where |media_task_runner_| is current.
   void ReturnFrameResources(FrameResources* frame_resources);
 
   // Delete resources. This has to be called on the thread where |task_runner|
   // is current.
   static void DeleteFrameResources(GpuVideoAcceleratorFactories* gpu_factories,
                                    FrameResources* frame_resources);
 
@@ skipping 409 matching lines @@
           VideoFrame::Rows(i, output_format_, coded_size.height());
       plane_resource.image_id = gles2->CreateImageCHROMIUM(
           plane_resource.gpu_memory_buffer->AsClientBuffer(), width, height,
           ImageInternalFormat(output_format_, i));
     } else if (plane_resource.image_id) {
       gles2->ReleaseTexImage2DCHROMIUM(texture_target_,
                                        plane_resource.image_id);
     }
     if (plane_resource.image_id)
       gles2->BindTexImage2DCHROMIUM(texture_target_, plane_resource.image_id);
-    mailbox_holders[i] =
-        gpu::MailboxHolder(plane_resource.mailbox, texture_target_, 0);
+    mailbox_holders[i] = gpu::MailboxHolder(plane_resource.mailbox,
+                                            gpu::SyncToken(), texture_target_);
   }
 
-  // Insert a sync_point, this is needed to make sure that the textures the
+  // Insert a sync_token, this is needed to make sure that the textures the
   // mailboxes refer to will be used only after all the previous commands posted
   // in the command buffer have been processed.
-  unsigned sync_point = gles2->InsertSyncPointCHROMIUM();
+  gpu::SyncToken sync_token(gles2->InsertSyncPointCHROMIUM());
   for (size_t i = 0; i < num_planes; i += planes_per_copy)
-    mailbox_holders[i].sync_point = sync_point;
+    mailbox_holders[i].sync_token = sync_token;
 
   scoped_refptr<VideoFrame> frame;
 
   auto release_mailbox_callback =
       base::Bind(&PoolImpl::MailboxHoldersReleased, this, frame_resources);
 
   // Create the VideoFrame backed by native textures.
   gfx::Size visible_size = video_frame->visible_rect().size();
   switch (output_format_) {
     case PIXEL_FORMAT_I420:
@@ skipping 108 matching lines @@
     if (plane_resource.image_id)
       gles2->DestroyImageCHROMIUM(plane_resource.image_id);
     if (plane_resource.texture_id)
       gles2->DeleteTextures(1, &plane_resource.texture_id);
   }
 }
 
 // Called when a VideoFrame is no longer references.
 void GpuMemoryBufferVideoFramePool::PoolImpl::MailboxHoldersReleased(
     FrameResources* frame_resources,
-    uint32 sync_point) {
+    const gpu::SyncToken& sync_token) {
   // Return the resource on the media thread.
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PoolImpl::ReturnFrameResources, this, frame_resources));
 }
 
 // Put back the resources in the pool.
 void GpuMemoryBufferVideoFramePool::PoolImpl::ReturnFrameResources(
     FrameResources* frame_resources) {
   auto it = std::find(resources_pool_.begin(), resources_pool_.end(),
@@ skipping 24 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media