Converted video frame and image callbacks to use new sync tokens.

media/base/video_frame_unittest.cc

 // 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.
 
 #include "media/base/video_frame.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/memory/aligned_memory.h"
@@ skipping 251 matching lines @@
 }
 
 static void TextureCallback(gpu::SyncToken* called_sync_token,
                             const gpu::SyncToken& release_sync_token) {
   *called_sync_token = release_sync_token;
 }
 
 // Verify the gpu::MailboxHolder::ReleaseCallback is called when VideoFrame is
 // destroyed with the default release sync point.
 TEST(VideoFrame, TextureNoLongerNeededCallbackIsCalled) {
-  gpu::SyncToken called_sync_token(1);
+  gpu::SyncToken called_sync_token(gpu::CommandBufferNamespace::GPU_IO, 1, 1);
 
   {
     scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture(
         PIXEL_FORMAT_ARGB,
         gpu::MailboxHolder(gpu::Mailbox::Generate(), gpu::SyncToken(), 5),
         base::Bind(&TextureCallback, &called_sync_token),
         gfx::Size(10, 10),   // coded_size
         gfx::Rect(10, 10),   // visible_rect
         gfx::Size(10, 10),   // natural_size
         base::TimeDelta());  // timestamp
     EXPECT_EQ(PIXEL_FORMAT_ARGB, frame->format());
     EXPECT_EQ(VideoFrame::STORAGE_OPAQUE, frame->storage_type());
     EXPECT_TRUE(frame->HasTextures());
   }
   // Nobody set a sync point to |frame|, so |frame| set |called_sync_token|
   // cleared to default value.
   EXPECT_FALSE(called_sync_token.HasData());
 }
 
 namespace {
 
 class SyncTokenClientImpl : public VideoFrame::SyncTokenClient {
  public:
   explicit SyncTokenClientImpl(const gpu::SyncToken& sync_token)
       : sync_token_(sync_token) {}
   ~SyncTokenClientImpl() override {}
-  uint32 InsertSyncPoint() override {
-    return static_cast<uint32>(sync_token_.release_count());
+  void GenerateSyncToken(gpu::SyncToken* sync_token) override {
+    *sync_token = sync_token_;
   }
   void WaitSyncToken(const gpu::SyncToken& sync_token) override {}
 
  private:
   gpu::SyncToken sync_token_;
 };
 
 }  // namespace
 
 // Verify the gpu::MailboxHolder::ReleaseCallback is called when VideoFrame is
 // destroyed with the release sync point, which was updated by clients.
 // (i.e. the compositor, webgl).
 TEST(VideoFrame,
      TexturesNoLongerNeededCallbackAfterTakingAndReleasingMailboxes) {
   const int kPlanesNum = 3;
+  const gpu::CommandBufferNamespace kNamespace =
+      gpu::CommandBufferNamespace::GPU_IO;
+  const uint64_t kCommandBufferId = 0x123;
   gpu::Mailbox mailbox[kPlanesNum];
   for (int i = 0; i < kPlanesNum; ++i) {
     mailbox[i].name[0] = 50 + 1;
   }
 
-  gpu::SyncToken sync_token(7);
+  gpu::SyncToken sync_token(kNamespace, kCommandBufferId, 7);
+  sync_token.SetVerifyFlush();
   uint32 target = 9;
-  gpu::SyncToken release_sync_token(111);
+  gpu::SyncToken release_sync_token(kNamespace, kCommandBufferId, 111);
+  release_sync_token.SetVerifyFlush();
+
   gpu::SyncToken called_sync_token;
   {
     scoped_refptr<VideoFrame> frame = VideoFrame::WrapYUV420NativeTextures(
         gpu::MailboxHolder(mailbox[VideoFrame::kYPlane], sync_token, target),
         gpu::MailboxHolder(mailbox[VideoFrame::kUPlane], sync_token, target),
         gpu::MailboxHolder(mailbox[VideoFrame::kVPlane], sync_token, target),
         base::Bind(&TextureCallback, &called_sync_token),
         gfx::Size(10, 10),   // coded_size
         gfx::Rect(10, 10),   // visible_rect
         gfx::Size(10, 10),   // natural_size
@@ skipping 142 matching lines @@
 
   for (int i = 0; i < VideoFrameMetadata::NUM_KEYS; ++i) {
     const VideoFrameMetadata::Key key = static_cast<VideoFrameMetadata::Key>(i);
     int value = -1;
     EXPECT_TRUE(result.GetInteger(key, &value));
     EXPECT_EQ(i, value);
   }
 }
 
 }  // namespace media