VideoCapture: migrate last Renderer-->Host msg and start Host-->Renderer migration

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 41 matching lines @@
 VideoCaptureImpl::ClientInfo::~ClientInfo() {}
 
 VideoCaptureImpl::VideoCaptureImpl(
     media::VideoCaptureSessionId session_id,
     VideoCaptureMessageFilter* filter,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : message_filter_(filter),
       device_id_(0),
       session_id_(session_id),
       video_capture_host_for_testing_(nullptr),
+      observer_binding_(this),
       state_(VIDEO_CAPTURE_STATE_STOPPED),
       io_task_runner_(std::move(io_task_runner)),
       weak_factory_(this) {
   DCHECK(filter);
   io_task_runner_->PostTask(FROM_HERE,
                             base::Bind(&VideoCaptureMessageFilter::AddDelegate,
                                        message_filter_, this));
 }
 
 VideoCaptureImpl::~VideoCaptureImpl() {
@@ skipping 20 matching lines @@
   ClientInfo client_info;
   client_info.params = params;
   client_info.state_update_cb = state_update_cb;
   client_info.deliver_frame_cb = deliver_frame_cb;
 
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     state_update_cb.Run(VIDEO_CAPTURE_STATE_ERROR);
   } else if (clients_pending_on_filter_.count(client_id) ||
              clients_pending_on_restart_.count(client_id) ||
              clients_.count(client_id)) {
-    LOG(FATAL) << "This client has already started.";
+    DLOG(FATAL) << __func__ << " This client has already started.";
   } else if (!device_id_) {
     clients_pending_on_filter_[client_id] = client_info;
   } else {
     // Note: |state_| might not be started at this point. But we tell
     // client that we have started.
     state_update_cb.Run(VIDEO_CAPTURE_STATE_STARTED);
     if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
       clients_[client_id] = client_info;
       // TODO(sheu): Allowing resolution change will require that all
       // outstanding clients of a capture session support resolution change.
       DCHECK_EQ(params_.resolution_change_policy,
                 params.resolution_change_policy);
     } else if (state_ == VIDEO_CAPTURE_STATE_STOPPING) {
       clients_pending_on_restart_[client_id] = client_info;
-      DVLOG(1) << "StartCapture: Got new resolution "
-               << params.requested_format.frame_size.ToString()
-               << " during stopping.";
+      DVLOG(1) << __func__ << " Got new resolution while stopping: "
+               << params.requested_format.frame_size.ToString();
     } else {
       clients_[client_id] = client_info;
       if (state_ == VIDEO_CAPTURE_STATE_STARTED)
         return;
       params_ = params;
-      if (params_.requested_format.frame_rate >
-          media::limits::kMaxFramesPerSecond) {
-        params_.requested_format.frame_rate =
-            media::limits::kMaxFramesPerSecond;
-      }
+      params_.requested_format.frame_rate =
+          std::min(params_.requested_format.frame_rate,
+                   static_cast<float>(media::limits::kMaxFramesPerSecond));
+
       DVLOG(1) << "StartCapture: starting with first resolution "
                << params_.requested_format.frame_size.ToString();
       StartCaptureInternal();
     }
   }
 }
 
 void VideoCaptureImpl::StopCapture(int client_id) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   // A client ID can be in only one client list.
@@ skipping 75 matching lines @@
 
 void VideoCaptureImpl::OnBufferReceived(
     int buffer_id,
     base::TimeDelta timestamp,
     const base::DictionaryValue& metadata,
     media::VideoPixelFormat pixel_format,
     media::VideoFrame::StorageType storage_type,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  // Crash in debug builds since the host should not have provided a buffer
-  // with an unsupported pixel format or storage type.
   DCHECK_EQ(media::PIXEL_FORMAT_I420, pixel_format);
-  DCHECK(storage_type == media::VideoFrame::STORAGE_SHMEM);
+  DCHECK_EQ(media::VideoFrame::STORAGE_SHMEM, storage_type);
+
   if (state_ != VIDEO_CAPTURE_STATE_STARTED ||
       pixel_format != media::PIXEL_FORMAT_I420 ||
       storage_type != media::VideoFrame::STORAGE_SHMEM) {
-    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id,
-                                             gpu::SyncToken(), -1.0));
+    GetVideoCaptureHost()->ReleaseBuffer(device_id_, buffer_id,
+                                         gpu::SyncToken(), -1.0);
     return;
   }
 
   base::TimeTicks reference_time;
   media::VideoFrameMetadata frame_metadata;
   frame_metadata.MergeInternalValuesFrom(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(
           pixel_format, coded_size, visible_rect,
           gfx::Size(visible_rect.width(), visible_rect.height()),
           reinterpret_cast<uint8_t*>(buffer->buffer()->memory()),
           buffer->buffer_size(), buffer->buffer()->handle(),
           0 /* shared_memory_offset */, timestamp);
   if (!frame) {
-    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id,
-                                             gpu::SyncToken(), -1.0));
+    GetVideoCaptureHost()->ReleaseBuffer(device_id_, buffer_id,
+                                         gpu::SyncToken(), -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));
 
   frame->metadata()->MergeInternalValuesFrom(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::OnClientBufferFinished(
-    int buffer_id,
-    const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
-    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_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;
-    case VIDEO_CAPTURE_STATE_STOPPED:
-      state_ = VIDEO_CAPTURE_STATE_STOPPED;
-      DVLOG(1) << "OnStateChanged: stopped!, device_id = " << device_id_;
-      client_buffers_.clear();
-      weak_factory_.InvalidateWeakPtrs();
-      if (!clients_.empty() || !clients_pending_on_restart_.empty())
-        RestartCapture();
-      break;
-    case VIDEO_CAPTURE_STATE_PAUSED:
-    case VIDEO_CAPTURE_STATE_RESUMED:
-      for (const auto& client : clients_)
-        client.second.state_update_cb.Run(state);
-      break;
-    case VIDEO_CAPTURE_STATE_ERROR:
-      DVLOG(1) << "OnStateChanged: error!, device_id = " << device_id_;
-      for (const auto& client : clients_)
-        client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_ERROR);
-      clients_.clear();
-      state_ = VIDEO_CAPTURE_STATE_ERROR;
-      break;
-    case VIDEO_CAPTURE_STATE_ENDED:
-      DVLOG(1) << "OnStateChanged: ended!, device_id = " << device_id_;
-      for (const auto& client : clients_) {
-        // We'll only notify the client that the stream has stopped.
-        client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
-      }
-      clients_.clear();
-      state_ = VIDEO_CAPTURE_STATE_ENDED;
-      break;
-    default:
-      break;
-  }
-}
-
 void VideoCaptureImpl::OnDelegateAdded(int32_t device_id) {
   DVLOG(1) << __func__ << " " << device_id;
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   device_id_ = device_id;
   ClientInfoMap::iterator it = clients_pending_on_filter_.begin();
   while (it != clients_pending_on_filter_.end()) {
     const int client_id = it->first;
     const ClientInfo client_info = it->second;
     clients_pending_on_filter_.erase(it++);
     StartCapture(client_id, client_info.params, client_info.state_update_cb,
                  client_info.deliver_frame_cb);
   }
 }
 
+void VideoCaptureImpl::OnStateChanged(mojom::VideoCaptureState state) {
+  DVLOG(1) << __func__ << " state: " << state;
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+
+  switch (state) {
+    case mojom::VideoCaptureState::STARTED:
+      // Capture has started in the browser process. Since we have already
+      // told all clients that we have started there's nothing to do.
+      break;
+    case mojom::VideoCaptureState::STOPPED:
+      state_ = VIDEO_CAPTURE_STATE_STOPPED;
+      client_buffers_.clear();
+      weak_factory_.InvalidateWeakPtrs();
+      if (!clients_.empty() || !clients_pending_on_restart_.empty())
+        RestartCapture();
+      break;
+    case mojom::VideoCaptureState::PAUSED:
+      for (const auto& client : clients_)
+        client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_PAUSED);
+      break;
+    case mojom::VideoCaptureState::RESUMED:
+      for (const auto& client : clients_)
+        client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_RESUMED);
+      break;
+    case mojom::VideoCaptureState::FAILED:
+      for (const auto& client : clients_)
+        client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_ERROR);
+      clients_.clear();
+      state_ = VIDEO_CAPTURE_STATE_ERROR;
+      break;
+    case mojom::VideoCaptureState::ENDED:
+      // We'll only notify the client that the stream has stopped.
+      for (const auto& client : clients_)
+        client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
+      clients_.clear();
+      state_ = VIDEO_CAPTURE_STATE_ENDED;
+      break;
+  }
+}
+
+void VideoCaptureImpl::OnClientBufferFinished(
+    int buffer_id,
+    const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
+    const gpu::SyncToken& release_sync_token,
+    double consumer_resource_utilization) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  GetVideoCaptureHost()->ReleaseBuffer(
+      device_id_, buffer_id, release_sync_token, consumer_resource_utilization);
+}
+
 void VideoCaptureImpl::StopDevice() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (state_ != VIDEO_CAPTURE_STATE_STARTED)
     return;
   state_ = VIDEO_CAPTURE_STATE_STOPPING;
   GetVideoCaptureHost()->Stop(device_id_);
   params_.requested_format.frame_size.SetSize(0, 0);
 }
 
 void VideoCaptureImpl::RestartCapture() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPED);
 
   int width = 0;
   int height = 0;
   clients_.insert(clients_pending_on_restart_.begin(),
                   clients_pending_on_restart_.end());
   clients_pending_on_restart_.clear();
   for (const auto& client : clients_) {
     width = std::max(width,
                      client.second.params.requested_format.frame_size.width());
     height = std::max(
         height, client.second.params.requested_format.frame_size.height());
   }
   params_.requested_format.frame_size.SetSize(width, height);
-  DVLOG(1) << "RestartCapture, "
-           << params_.requested_format.frame_size.ToString();
+  DVLOG(1) << __func__ << " " << params_.requested_format.frame_size.ToString();
   StartCaptureInternal();
 }
 
 void VideoCaptureImpl::StartCaptureInternal() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   DCHECK(device_id_);
 
-  GetVideoCaptureHost()->Start(device_id_, session_id_, params_);
+  GetVideoCaptureHost()->Start(device_id_, session_id_, params_,
+                               observer_binding_.CreateInterfacePtrAndBind());
   state_ = VIDEO_CAPTURE_STATE_STARTED;
 }
 
 void VideoCaptureImpl::OnDeviceSupportedFormats(
     const VideoCaptureDeviceFormatsCB& callback,
     const media::VideoCaptureFormats& supported_formats) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   callback.Run(supported_formats);
 }
 
@@ skipping 47 matching lines @@
   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);
 }
 
 }  // namespace content