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

media/base/video_frame.h

 // Copyright (c) 2012 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.
 
 #ifndef MEDIA_BASE_VIDEO_FRAME_H_
 #define MEDIA_BASE_VIDEO_FRAME_H_
 
 #include <vector>
 
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/md5.h"
 #include "base/memory/shared_memory.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_frame_metadata.h"
 #include "media/base/video_types.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(OS_MACOSX)
@@ skipping 49 matching lines @@
     STORAGE_LAST = STORAGE_HOLE,
 #elif defined(OS_LINUX)
     STORAGE_LAST = STORAGE_DMABUFS,
 #else
     STORAGE_LAST = STORAGE_SHMEM
 #endif
   };
 
   // CB to be called on the mailbox backing this frame when the frame is
   // destroyed.
-  typedef base::Callback<void(uint32)> ReleaseMailboxCB;
+  typedef base::Callback<void(const gpu::SyncToken&)> ReleaseMailboxCB;
 
-  // Interface representing client operations on a SyncPoint, i.e. insert one in
+  // Interface representing client operations on a SyncToken, i.e. insert one in
   // the GPU Command Buffer and wait for it.
-  class SyncPointClient {
+  class SyncTokenClient {
    public:
-    SyncPointClient() {}
+    SyncTokenClient() {}
     virtual uint32 InsertSyncPoint() = 0;
-    virtual void WaitSyncPoint(uint32 sync_point) = 0;
+    virtual void WaitSyncToken(const gpu::SyncToken& sync_token) = 0;
 
    protected:
-    virtual ~SyncPointClient() {}
+    virtual ~SyncTokenClient() {}
 
-    DISALLOW_COPY_AND_ASSIGN(SyncPointClient);
+    DISALLOW_COPY_AND_ASSIGN(SyncTokenClient);
   };
 
   // Call prior to CreateFrame to ensure validity of frame configuration. Called
   // automatically by VideoDecoderConfig::IsValidConfig().
   static bool IsValidConfig(VideoPixelFormat format,
                             StorageType storage_type,
                             const gfx::Size& coded_size,
                             const gfx::Rect& visible_rect,
                             const gfx::Size& natural_size);
 
@@ skipping 13 matching lines @@
   static scoped_refptr<VideoFrame> CreateZeroInitializedFrame(
       VideoPixelFormat format,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp);
 
   // Wraps a native texture of the given parameters with a VideoFrame.
   // The backing of the VideoFrame is held in the mailbox held by
   // |mailbox_holder|, and |mailbox_holder_release_cb| will be called with
-  // a syncpoint as the argument when the VideoFrame is to be destroyed.
+  // a sync token as the argument when the VideoFrame is to be destroyed.
   static scoped_refptr<VideoFrame> WrapNativeTexture(
       VideoPixelFormat format,
       const gpu::MailboxHolder& mailbox_holder,
       const ReleaseMailboxCB& mailbox_holder_release_cb,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp);
 
   // Wraps a set of native textures representing YUV data with a VideoFrame.
-  // |mailbox_holders_release_cb| will be called with a syncpoint as the
+  // |mailbox_holders_release_cb| will be called with a sync token as the
   // argument when the VideoFrame is to be destroyed.
   static scoped_refptr<VideoFrame> WrapYUV420NativeTextures(
       const gpu::MailboxHolder& y_mailbox_holder,
       const gpu::MailboxHolder& u_mailbox_holder,
       const gpu::MailboxHolder& v_mailbox_holder,
       const ReleaseMailboxCB& mailbox_holders_release_cb,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp);
@@ skipping 228 matching lines @@
   // See VideoFrameMetadata::REFERENCE_TIME for details.
   base::TimeDelta timestamp() const { return timestamp_; }
   void set_timestamp(base::TimeDelta timestamp) {
     timestamp_ = timestamp;
   }
 
   // It uses |client| to insert a new sync point and potentially waits on a
   // older sync point. The final sync point will be used to release this
   // VideoFrame.
   // This method is thread safe. Both blink and compositor threads can call it.
-  void UpdateReleaseSyncPoint(SyncPointClient* client);
+  void UpdateReleaseSyncToken(SyncTokenClient* client);
 
  private:
   friend class base::RefCountedThreadSafe<VideoFrame>;
 
   static scoped_refptr<VideoFrame> WrapExternalStorage(
       VideoPixelFormat format,
       StorageType storage_type,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
@@ skipping 86 matching lines @@
 
 #if defined(OS_MACOSX)
   // CVPixelBuffer, if this frame is wrapping one.
   base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer_;
 #endif
 
   std::vector<base::Closure> done_callbacks_;
 
   base::TimeDelta timestamp_;
 
-  base::Lock release_sync_point_lock_;
-  uint32 release_sync_point_;
+  base::Lock release_sync_token_lock_;
+  gpu::SyncToken release_sync_token_;
 
   VideoFrameMetadata metadata_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_