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

content/browser/renderer_host/media/video_capture_controller_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.
 
 // Unit test for VideoCaptureController.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 68 matching lines @@
     DoBufferDestroyed(id);
   }
   void OnBufferReady(VideoCaptureControllerID id,
                      int buffer_id,
                      const scoped_refptr<media::VideoFrame>& frame,
                      const base::TimeTicks& timestamp) override {
     if (!frame->HasTextures()) {
       EXPECT_EQ(frame->format(), media::PIXEL_FORMAT_I420);
       DoI420BufferReady(id, frame->coded_size());
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&VideoCaptureController::ReturnBuffer,
-                                base::Unretained(controller_), id, this,
-                                buffer_id, 0, resource_utilization_));
+          FROM_HERE,
+          base::Bind(&VideoCaptureController::ReturnBuffer,
+                     base::Unretained(controller_), id, this, buffer_id, 0,
+                     gpu::SyncToken(), resource_utilization_));
     } else {
       EXPECT_EQ(frame->format(), media::PIXEL_FORMAT_ARGB);
       DoTextureBufferReady(id, frame->coded_size());
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&VideoCaptureController::ReturnBuffer,
                                 base::Unretained(controller_), id, this,
-                                buffer_id, frame->mailbox_holder(0).sync_point,
+                                buffer_id, frame->mailbox_holder(0).sync_token,
                                 resource_utilization_));
     }
   }
   void OnEnded(VideoCaptureControllerID id) override {
     DoEnded(id);
     // OnEnded() must respond by (eventually) unregistering the client.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&VideoCaptureController::RemoveClient),
                    base::Unretained(controller_), id, this));
@@ skipping 145 matching lines @@
   ASSERT_EQ(1, controller_->GetClientCount())
       << "Removing non-existant session 200 should be a no-op.";
   ASSERT_EQ(400,
       controller_->RemoveClient(client_b_route_2, client_b_.get()))
       << "Removing client B/2 should return its session_id.";
   // Clients in controller: []
   ASSERT_EQ(0, controller_->GetClientCount())
       << "Client count should return to zero after all clients are gone.";
 }
 
-static void CacheSyncPoint(uint32* called_release_sync_point,
-                           uint32 release_sync_point) {
-  *called_release_sync_point = release_sync_point;
+static void CacheSyncToken(gpu::SyncToken* called_release_sync_token,
+                           const gpu::SyncToken& release_sync_token) {
+  *called_release_sync_token = release_sync_token;
 }
 
 // This test will connect and disconnect several clients while simulating an
 // active capture device being started and generating frames. It runs on one
 // thread and is intended to behave deterministically.
 TEST_F(VideoCaptureControllerTest, NormalCaptureMultipleClients) {
 // VideoCaptureController::ReturnBuffer() uses ImageTransportFactory.
 #if !defined(OS_ANDROID)
   ImageTransportFactory::InitializeForUnitTests(
       scoped_ptr<ImageTransportFactory>(new NoTransportImageTransportFactory));
@@ skipping 241 matching lines @@
     scoped_ptr<media::VideoCaptureDevice::Client::Buffer> buffer =
         device_->ReserveOutputBuffer(capture_resolution,
                                      media::PIXEL_FORMAT_I420,
                                      media::PIXEL_STORAGE_CPU);
     ASSERT_TRUE(buffer.get());
     video_frame =
         WrapI420Buffer(capture_resolution, static_cast<uint8*>(buffer->data()));
     device_->OnIncomingCapturedVideoFrame(buffer.Pass(), video_frame,
                                           base::TimeTicks());
   }
-  std::vector<uint32> mailbox_syncpoints(mailbox_buffers);
-  std::vector<uint32> release_syncpoints(mailbox_buffers);
+  std::vector<gpu::SyncToken> mailbox_synctokens(mailbox_buffers);
+  std::vector<gpu::SyncToken> release_synctokens(mailbox_buffers);
   for (int i = 0; i < mailbox_buffers; ++i) {
     scoped_ptr<media::VideoCaptureDevice::Client::Buffer> buffer =
         device_->ReserveOutputBuffer(capture_resolution,
                                      media::PIXEL_FORMAT_ARGB,
                                      media::PIXEL_STORAGE_TEXTURE);
     ASSERT_TRUE(buffer.get());
 #if !defined(OS_ANDROID)
-    mailbox_syncpoints[i] =
-        ImageTransportFactory::GetInstance()->GetGLHelper()->InsertSyncPoint();
+    mailbox_synctokens[i] = gpu::SyncToken(
+        ImageTransportFactory::GetInstance()->GetGLHelper()->InsertSyncPoint());
 #endif
     device_->OnIncomingCapturedVideoFrame(
         buffer.Pass(),
-        WrapMailboxBuffer(gpu::MailboxHolder(gpu::Mailbox::Generate(), 0,
-                                             mailbox_syncpoints[i]),
-                          base::Bind(&CacheSyncPoint, &release_syncpoints[i]),
+        WrapMailboxBuffer(gpu::MailboxHolder(gpu::Mailbox::Generate(),
+                                             mailbox_synctokens[i], 0),
+                          base::Bind(&CacheSyncToken, &release_synctokens[i]),
                           capture_resolution),
         base::TimeTicks());
   }
   // ReserveOutputBuffers ought to fail now regardless of buffer format, because
   // the pool is depleted.
   ASSERT_FALSE(
       device_->ReserveOutputBuffer(capture_resolution,
                                    media::PIXEL_FORMAT_I420,
                                    media::PIXEL_STORAGE_CPU).get());
   ASSERT_FALSE(
       device_->ReserveOutputBuffer(capture_resolution,
                                    media::PIXEL_FORMAT_ARGB,
                                    media::PIXEL_STORAGE_TEXTURE).get());
   EXPECT_CALL(*client_b_,
               DoI420BufferReady(client_b_route_2, capture_resolution))
       .Times(shm_buffers);
   EXPECT_CALL(*client_b_,
               DoTextureBufferReady(client_b_route_2, capture_resolution))
       .Times(mailbox_buffers);
 #if !defined(OS_ANDROID)
   EXPECT_CALL(*client_b_, DoBufferDestroyed(client_b_route_2));
 #endif
   base::RunLoop().RunUntilIdle();
-  for (size_t i = 0; i < mailbox_syncpoints.size(); ++i) {
+  for (size_t i = 0; i < mailbox_synctokens.size(); ++i) {
     // A new release sync point must be inserted when the video frame is
     // returned to the Browser process.
     // See: MockVideoCaptureControllerEventHandler::OnMailboxBufferReady() and
     // VideoCaptureController::ReturnBuffer()
-    ASSERT_NE(mailbox_syncpoints[i], release_syncpoints[i]);
+    ASSERT_NE(mailbox_synctokens[i], release_synctokens[i]);
   }
   Mock::VerifyAndClearExpectations(client_b_.get());
 
 #if !defined(OS_ANDROID)
   ImageTransportFactory::Terminate();
 #endif
 }
 
 // Exercises the OnError() codepath of VideoCaptureController, and tests the
 // behavior of various operations after the error state has been signalled.
@@ skipping 78 matching lines @@
 
   // Second client connects after the error state. It also should get told of
   // the error.
   EXPECT_CALL(*client_b_, DoError(route_id)).Times(1);
   controller_->AddClient(
       route_id, client_b_.get(), base::kNullProcessHandle, 200, session_200);
   Mock::VerifyAndClearExpectations(client_b_.get());
 }
 
 }  // namespace content