Rebase of Removing gpu::SyncToken usage from video capture pipeline

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 251 matching lines @@
   bool consume_buffer = state_ == VIDEO_CAPTURE_STATE_STARTED;
   if ((info->pixel_format != media::PIXEL_FORMAT_I420 &&
        info->pixel_format != media::PIXEL_FORMAT_Y16) ||
       info->storage_type != media::PIXEL_STORAGE_CPU) {
     consume_buffer = false;
     LOG(DFATAL) << "Wrong pixel format or storage, got pixel format:"
                 << VideoPixelFormatToString(info->pixel_format)
                 << ", storage:" << info->storage_type;
   }
   if (!consume_buffer) {
-    GetVideoCaptureHost()->ReleaseBuffer(device_id_, buffer_id,
-                                         gpu::SyncToken(), -1.0);
+    GetVideoCaptureHost()->ReleaseBuffer(device_id_, buffer_id, -1.0);
     return;
   }
 
   base::TimeTicks reference_time;
   media::VideoFrameMetadata frame_metadata;
   frame_metadata.MergeInternalValuesFrom(*info->metadata);
   const bool success = frame_metadata.GetTimeTicks(
       media::VideoFrameMetadata::REFERENCE_TIME, &reference_time);
   DCHECK(success);
 
@@ skipping 19 matching lines @@
   DCHECK(iter != client_buffers_.end());
   const scoped_refptr<ClientBuffer> buffer = iter->second;
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::WrapExternalSharedMemory(
           static_cast<media::VideoPixelFormat>(info->pixel_format),
           info->coded_size, info->visible_rect, info->visible_rect.size(),
           reinterpret_cast<uint8_t*>(buffer->buffer()->memory()),
           buffer->buffer_size(), buffer->buffer()->handle(),
           0 /* shared_memory_offset */, info->timestamp);
   if (!frame) {
-    GetVideoCaptureHost()->ReleaseBuffer(device_id_, buffer_id,
-                                         gpu::SyncToken(), -1.0);
+    GetVideoCaptureHost()->ReleaseBuffer(device_id_, buffer_id, -1.0);
     return;
   }
 
   BufferFinishedCallback buffer_finished_callback = media::BindToCurrentLoop(
       base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
                  weak_factory_.GetWeakPtr(), buffer_id, buffer));
-  std::unique_ptr<gpu::SyncToken> release_sync_token(new gpu::SyncToken);
   frame->AddDestructionObserver(
       base::Bind(&VideoCaptureImpl::DidFinishConsumingFrame, frame->metadata(),
-                 base::Passed(&release_sync_token), buffer_finished_callback));
+                 buffer_finished_callback));
 
   frame->metadata()->MergeInternalValuesFrom(*info->metadata);
 
   // TODO(qiangchen): Dive into the full code path to let frame metadata hold
   // reference time rather than using an extra parameter.
   for (const auto& client : clients_)
     client.second.deliver_frame_cb.Run(frame, reference_time);
 }
 
 void VideoCaptureImpl::OnBufferDestroyed(int32_t buffer_id) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
 
   const auto& cb_iter = client_buffers_.find(buffer_id);
   if (cb_iter != client_buffers_.end()) {
     DCHECK(!cb_iter->second.get() || cb_iter->second->HasOneRef())
         << "Instructed to delete buffer we are still using.";
     client_buffers_.erase(cb_iter);
   }
 }
 
 void VideoCaptureImpl::OnClientBufferFinished(
     int buffer_id,
     const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
-    const gpu::SyncToken& release_sync_token,
     double consumer_resource_utilization) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   GetVideoCaptureHost()->ReleaseBuffer(
-      device_id_, buffer_id, release_sync_token, consumer_resource_utilization);
+      device_id_, buffer_id, consumer_resource_utilization);
 }
 
 void VideoCaptureImpl::StopDevice() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   if (state_ != VIDEO_CAPTURE_STATE_STARTED)
     return;
   state_ = VIDEO_CAPTURE_STATE_STOPPING;
   GetVideoCaptureHost()->Stop(device_id_);
   params_.requested_format.frame_size.SetSize(0, 0);
 }
@@ skipping 58 matching lines @@
     return video_capture_host_for_testing_;
 
   if (!video_capture_host_.get())
     video_capture_host_.Bind(std::move(video_capture_host_info_));
   return video_capture_host_.get();
 };
 
 // static
 void VideoCaptureImpl::DidFinishConsumingFrame(
     const media::VideoFrameMetadata* metadata,
-    std::unique_ptr<gpu::SyncToken> release_sync_token,
     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.
   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_token, consumer_resource_utilization);
+  callback_to_io_thread.Run(consumer_resource_utilization);
 }
 
 }  // namespace content