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

content/renderer/media/video_capture_impl.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.
 //
 // Notes about usage of this object by VideoCaptureImplManager.
 //
 // VideoCaptureImplManager access this object by using a Unretained()
 // binding and tasks on the IO thread. It is then important that
 // VideoCaptureImpl never post task to itself. All operations must be
 // synchronous.
@@ skipping 13 matching lines @@
 namespace content {
 
 namespace {
 
 // This is called on an unknown thread when the VideoFrame destructor executes.
 // As of this writing, this callback mechanism is the only interface in
 // VideoFrame to provide the final value for |release_sync_point|.
 // VideoCaptureImpl::DidFinishConsumingFrame() will read the value saved here,
 // and pass it back to the IO thread to pass back to the host via the
 // BufferReady IPC.
-void SaveReleaseSyncPoint(uint32* storage, uint32 release_sync_point) {
-  *storage = release_sync_point;
+void SaveReleaseSyncPoint(uint32* sync_point_storage,
+                          gpu::SyncToken* sync_token_storage,
+                          uint32 release_sync_point,
+                          const gpu::SyncToken& release_sync_token) {
+  *sync_point_storage = release_sync_point;
+  *sync_token_storage = release_sync_token;
 }
 
 }  // namespace
 
 // A holder of a memory-backed buffer and accessors to it.
 class VideoCaptureImpl::ClientBuffer
     : public base::RefCountedThreadSafe<ClientBuffer> {
  public:
   ClientBuffer(scoped_ptr<base::SharedMemory> buffer, size_t buffer_size)
       : buffer_(buffer.Pass()), buffer_size_(buffer_size) {}
@@ skipping 261 matching lines @@
     int buffer_id,
     base::TimeTicks timestamp,
     const base::DictionaryValue& metadata,
     media::VideoPixelFormat pixel_format,
     media::VideoFrame::StorageType storage_type,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const std::vector<gpu::MailboxHolder>& mailbox_holders) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
-    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0, -1.0));
+    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0,
+                                             gpu::SyncToken(), -1.0));
     return;
   }
   if (first_frame_timestamp_.is_null())
     first_frame_timestamp_ = timestamp;
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2("cast_perf_test", "OnBufferReceived",
                        TRACE_EVENT_SCOPE_THREAD, "timestamp",
                        timestamp.ToInternalValue(), "time_delta",
                        (timestamp - first_frame_timestamp_).ToInternalValue());
 
   scoped_refptr<media::VideoFrame> frame;
-  base::Callback<void(uint32, double)> buffer_finished_callback;
+  BufferFinishedCB buffer_finished_callback;
   uint32* release_sync_point_storage = new uint32(0);
+  gpu::SyncToken* release_sync_token_storage = new gpu::SyncToken;

[dcheng, 2015/10/27 19:09:28]

It doesn't have to be this CL, but can we make ownership of these objects
clearer in a followup patch? Can we use scoped_ptr<> to manage the storage, for
instance?

[David Yen, 2015/10/28 22:03:43]

I will create a follow up CL for this.

   if (mailbox_holders.empty()) {
     DCHECK_EQ(media::PIXEL_FORMAT_I420, pixel_format);
     const auto& iter = client_buffers_.find(buffer_id);
     DCHECK(iter != client_buffers_.end());
     const scoped_refptr<ClientBuffer> buffer = iter->second;
     frame = media::VideoFrame::WrapExternalSharedMemory(
         pixel_format,
         coded_size,
         visible_rect,
         gfx::Size(visible_rect.width(), visible_rect.height()),
@@ skipping 10 matching lines @@
     for (const auto& mailbox_holder : mailbox_holders)
       DCHECK(mailbox_holder.mailbox.Verify());
     DCHECK(mailbox_holders.size() == 1u || mailbox_holders.size() == 3u);
 #endif
 
     scoped_refptr<ClientBuffer2> buffer;
     if (mailbox_holders.size() ==
         media::VideoFrame::NumPlanes(media::PIXEL_FORMAT_ARGB)) {
       DCHECK_EQ(media::PIXEL_FORMAT_ARGB, pixel_format);
       frame = media::VideoFrame::WrapNativeTexture(
-          pixel_format,
-          mailbox_holders[0],
-          base::Bind(&SaveReleaseSyncPoint, release_sync_point_storage),
-          coded_size,
-          gfx::Rect(coded_size),
-          coded_size,
+          pixel_format, mailbox_holders[0],
+          base::Bind(&SaveReleaseSyncPoint, release_sync_point_storage,
+                     release_sync_token_storage),
+          coded_size, gfx::Rect(coded_size), coded_size,
           timestamp - first_frame_timestamp_);
     } else if (mailbox_holders.size() ==
                media::VideoFrame::NumPlanes(media::PIXEL_FORMAT_I420)) {
       DCHECK_EQ(media::PIXEL_FORMAT_I420, pixel_format);
       const auto& iter = client_buffer2s_.find(buffer_id);
       DCHECK(iter != client_buffer2s_.end());
       buffer = iter->second;
       frame = media::VideoFrame::WrapYUV420NativeTextures(
           mailbox_holders[media::VideoFrame::kYPlane],
           mailbox_holders[media::VideoFrame::kUPlane],
           mailbox_holders[media::VideoFrame::kVPlane],
-          base::Bind(&SaveReleaseSyncPoint, release_sync_point_storage),
-          coded_size,
-          gfx::Rect(coded_size),
-          coded_size,
+          base::Bind(&SaveReleaseSyncPoint, release_sync_point_storage,
+                     release_sync_token_storage),
+          coded_size, gfx::Rect(coded_size), coded_size,
           timestamp - first_frame_timestamp_);
     }
     buffer_finished_callback = media::BindToCurrentLoop(
         base::Bind(&VideoCaptureImpl::OnClientBufferFinished2,
                    weak_factory_.GetWeakPtr(), buffer_id, buffer));
   }
   frame->metadata()->SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
                                   timestamp);
   frame->AddDestructionObserver(
       base::Bind(&VideoCaptureImpl::DidFinishConsumingFrame, frame->metadata(),
-                 release_sync_point_storage, buffer_finished_callback));
+                 release_sync_point_storage, release_sync_token_storage,
+                 buffer_finished_callback));
 
   frame->metadata()->MergeInternalValuesFrom(metadata);
 
   for (const auto& client : clients_)
     client.second.deliver_frame_cb.Run(frame, timestamp);
 }
 
 void VideoCaptureImpl::OnClientBufferFinished(
     int buffer_id,
     const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
     uint32 release_sync_point,
+    const gpu::SyncToken& release_sync_token,
     double consumer_resource_utilization) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id,
-                                           release_sync_point,
-                                           consumer_resource_utilization));
+  Send(new VideoCaptureHostMsg_BufferReady(
+      device_id_, buffer_id, release_sync_point, release_sync_token,
+      consumer_resource_utilization));
 }
 void VideoCaptureImpl::OnClientBufferFinished2(
     int buffer_id,
     const scoped_refptr<ClientBuffer2>& gpu_memory_buffer /* ignored_buffer */,
     uint32 release_sync_point,
+    const gpu::SyncToken& release_sync_token,
     double consumer_resource_utilization) {
   OnClientBufferFinished(buffer_id, scoped_refptr<ClientBuffer>(),
-                         release_sync_point, consumer_resource_utilization);
+                         release_sync_point, release_sync_token,
+                         consumer_resource_utilization);
 }
 
 void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   switch (state) {
     case VIDEO_CAPTURE_STATE_STARTED:
       // Camera has started in the browser process. Since we have already
       // told all clients that we have started there's nothing to do.
       break;
@@ skipping 116 matching lines @@
     clients->erase(it);
     found = true;
   }
   return found;
 }
 
 // static
 void VideoCaptureImpl::DidFinishConsumingFrame(
     const media::VideoFrameMetadata* metadata,
     uint32* release_sync_point_storage,
-    const base::Callback<void(uint32, double)>& callback_to_io_thread) {
+    gpu::SyncToken* release_sync_token_storage,
+    const BufferFinishedCB& callback_to_io_thread) {
   // Note: This function may be called on any thread by the VideoFrame
   // destructor.  |metadata| is still valid for read-access at this point.
 
   uint32 release_sync_point = 0u;
   if (release_sync_point_storage) {
     release_sync_point = *release_sync_point_storage;
     delete release_sync_point_storage;
   }
 
+  gpu::SyncToken release_sync_token;
+  if (release_sync_token_storage) {
+    release_sync_token = *release_sync_token_storage;
+    delete release_sync_token_storage;
+  }
+
   double consumer_resource_utilization = -1.0;
   if (!metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                            &consumer_resource_utilization)) {
     consumer_resource_utilization = -1.0;
   }
 
-  callback_to_io_thread.Run(release_sync_point, consumer_resource_utilization);
+  callback_to_io_thread.Run(release_sync_point, release_sync_token,
+                            consumer_resource_utilization);
 }
 
 }  // namespace content