RESOURCE_UTILIZATION in VideoFrameMetadata, a consumer feedback signal.

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/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|.
+// 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;
+}
+
+}  // namespace
+
 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) {}
   const scoped_ptr<base::SharedMemory> buffer;
   const size_t buffer_size;
 
@@ skipping 178 matching lines @@
 }
 
 void VideoCaptureImpl::OnBufferReceived(int buffer_id,
                                         const gfx::Size& coded_size,
                                         const gfx::Rect& visible_rect,
                                         base::TimeTicks timestamp,
                                         const base::DictionaryValue& metadata) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
-    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0));
+    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0, -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());
 
   const ClientBufferMap::const_iterator iter = client_buffers_.find(buffer_id);
   DCHECK(iter != client_buffers_.end());
   scoped_refptr<ClientBuffer> buffer = iter->second;
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::WrapExternalSharedMemory(
           media::VideoFrame::I420,
           coded_size,
           visible_rect,
           gfx::Size(visible_rect.width(), visible_rect.height()),
           reinterpret_cast<uint8*>(buffer->buffer->memory()),
           buffer->buffer_size,
           buffer->buffer->handle(),
           0,
           timestamp - first_frame_timestamp_);
   frame->AddDestructionObserver(
-      media::BindToCurrentLoop(
-          base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
-                     weak_factory_.GetWeakPtr(),
-                     buffer_id,
-                     buffer,
-                     0)));
+      base::Bind(&VideoCaptureImpl::DidFinishConsumingFrame,
+                 frame->metadata(),
+                 nullptr,
+                 media::BindToCurrentLoop(
+                     base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
+                                weak_factory_.GetWeakPtr(),
+                                buffer_id,
+                                buffer))));
   frame->metadata()->MergeInternalValuesFrom(metadata);
 
   for (const auto& client : clients_)
     client.second.deliver_frame_cb.Run(frame, timestamp);
 }
 
 void VideoCaptureImpl::OnMailboxBufferReceived(
     int buffer_id,
     const gpu::MailboxHolder& mailbox_holder,
     const gfx::Size& packed_frame_size,
     base::TimeTicks timestamp,
     const base::DictionaryValue& metadata) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
-    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0));
+    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0, -1.0));
     return;
   }
 
   if (first_frame_timestamp_.is_null())
     first_frame_timestamp_ = timestamp;
 
+  uint32* const release_sync_point_storage =
+      new uint32(0);  // Deleted in DidFinishConsumingFrame().
   scoped_refptr<media::VideoFrame> frame = media::VideoFrame::WrapNativeTexture(
       mailbox_holder,
-      media::BindToCurrentLoop(base::Bind(
-          &VideoCaptureImpl::OnClientBufferFinished, weak_factory_.GetWeakPtr(),
-          buffer_id, scoped_refptr<ClientBuffer>())),
+      base::Bind(&SaveReleaseSyncPoint, release_sync_point_storage),
       packed_frame_size, gfx::Rect(packed_frame_size), packed_frame_size,
       timestamp - first_frame_timestamp_, false /* allow_overlay */,
       true /* has_alpha */);
+  frame->AddDestructionObserver(
+      base::Bind(&VideoCaptureImpl::DidFinishConsumingFrame,
+                 frame->metadata(),
+                 release_sync_point_storage,
+                 media::BindToCurrentLoop(base::Bind(
+                     &VideoCaptureImpl::OnClientBufferFinished,
+                     weak_factory_.GetWeakPtr(),
+                     buffer_id,
+                     scoped_refptr<ClientBuffer>()))));
+
   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) {
+    uint32 release_sync_point,
+    double consumer_resource_utilization) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  Send(new VideoCaptureHostMsg_BufferReady(
-      device_id_, buffer_id, release_sync_point));
+  Send(new VideoCaptureHostMsg_BufferReady(device_id_,
+                                           buffer_id,
+                                           release_sync_point,
+                                           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 111 matching lines @@
 
   const ClientInfoMap::iterator it = clients->find(client_id);
   if (it != clients->end()) {
     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) {
+  // 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;
+  }
+
+  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);
+}
+
 }  // namespace content