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.
 
 #include "content/renderer/media/video_capture_impl.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 #include "content/common/media/video_capture_messages.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 
 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|.
+// VideoFrame to provide the final value for |release_sync_token|.
 // 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 SaveReleaseSyncToken(gpu::SyncToken* sync_token_storage,
+                          const gpu::SyncToken& release_sync_token) {
+  *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 262 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 gpu::MailboxHolder& mailbox_holder) {
   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,
+                                             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;
-  uint32* release_sync_point_storage = new uint32(0);
+  BufferFinishedCallback buffer_finished_callback;
+  gpu::SyncToken* release_sync_token_storage = new gpu::SyncToken;
   if (storage_type == media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS) {
     DCHECK_EQ(media::PIXEL_FORMAT_I420, pixel_format);
     const auto& iter = client_buffer2s_.find(buffer_id);
     DCHECK(iter != client_buffer2s_.end());
     scoped_refptr<ClientBuffer2> buffer = iter->second;
     const auto& handles = buffer->gpu_memory_buffer_handles();
     frame = media::VideoFrame::WrapExternalYuvGpuMemoryBuffers(
         media::PIXEL_FORMAT_I420,
         coded_size,
         gfx::Rect(coded_size),
@@ skipping 28 matching lines @@
           reinterpret_cast<uint8*>(buffer->buffer()->memory()),
           buffer->buffer_size(),
           buffer->buffer()->handle(),
           0 /* shared_memory_offset */,
           timestamp - first_frame_timestamp_);
     } else {
       DCHECK_EQ(storage_type, media::VideoFrame::STORAGE_OPAQUE);
       DCHECK(mailbox_holder.mailbox.Verify());
       DCHECK_EQ(media::PIXEL_FORMAT_ARGB, pixel_format);
       frame = media::VideoFrame::WrapNativeTexture(
-          pixel_format,
-          mailbox_holder,
-          base::Bind(&SaveReleaseSyncPoint, release_sync_point_storage),
-          coded_size,
-          gfx::Rect(coded_size),
-          coded_size,
+          pixel_format, mailbox_holder,
+          base::Bind(&SaveReleaseSyncToken, release_sync_token_storage),
+          coded_size, gfx::Rect(coded_size), coded_size,
           timestamp - first_frame_timestamp_);
     }
     buffer_finished_callback = media::BindToCurrentLoop(
         base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
                    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_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,
+                                           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_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 115 matching lines @@
     it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
     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 BufferFinishedCallback& 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_token, consumer_resource_utilization);
 }
 
 }  // namespace content