getUserMedia: handle the device starting status report.

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 65 matching lines @@
   if (ChildThread::Get()) {  // This will be null in unit tests.
     mojom::VideoCaptureHostPtr temp_video_capture_host;
     ChildThread::Get()->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&temp_video_capture_host));
     video_capture_host_info_ = temp_video_capture_host.PassInterface();
   }
 }
 
 VideoCaptureImpl::~VideoCaptureImpl() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
-  if (state_ == VIDEO_CAPTURE_STATE_STARTED && GetVideoCaptureHost())
+  if ((state_ == VIDEO_CAPTURE_STATE_STARTING ||
+       state_ == VIDEO_CAPTURE_STATE_STARTED) &&
+      GetVideoCaptureHost())
     GetVideoCaptureHost()->Stop(device_id_);
 }
 
 void VideoCaptureImpl::SuspendCapture(bool suspend) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   if (suspend)
     GetVideoCaptureHost()->Pause(device_id_);
   else
     GetVideoCaptureHost()->Resume(device_id_, session_id_, params_);
 }
 
 void VideoCaptureImpl::StartCapture(
     int client_id,
     const media::VideoCaptureParams& params,
     const VideoCaptureStateUpdateCB& state_update_cb,
     const VideoCaptureDeliverFrameCB& deliver_frame_cb) {
   DVLOG(1) << __func__ << " |device_id_| = " << device_id_;
   DCHECK(io_thread_checker_.CalledOnValidThread());
   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_restart_.count(client_id) ||
-             clients_.count(client_id)) {
-    DLOG(FATAL) << __func__ << " This client has already started.";
-  } 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) {
+  switch (state_) {
+    case VIDEO_CAPTURE_STATE_STARTING:
+    case 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) {
+      return;
+    case VIDEO_CAPTURE_STATE_STOPPING:
       clients_pending_on_restart_[client_id] = client_info;
       DVLOG(1) << __func__ << " Got new resolution while stopping: "
                << params.requested_format.frame_size.ToString();
-    } else {
+      return;
+    case VIDEO_CAPTURE_STATE_STOPPED:
+    case VIDEO_CAPTURE_STATE_ENDED:
       clients_[client_id] = client_info;
-      if (state_ == VIDEO_CAPTURE_STATE_STARTED)
-        return;
       params_ = params;
       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();
-    }
+      return;
+    case VIDEO_CAPTURE_STATE_ERROR:
+      state_update_cb.Run(VIDEO_CAPTURE_STATE_ERROR);
+      return;
+    case VIDEO_CAPTURE_STATE_PAUSED:
+    case VIDEO_CAPTURE_STATE_RESUMED:
+      // Do nothing becase these states aren't taken here.

[miu, 2017/03/10 23:56:56]

nit: Please add NOT_REACHED() here for safety. The comment should say something
like: The internal |state_| is never set to PAUSED/RESUMED since
VideoCaptureImpl is not modified by those.

[braveyao, 2017/03/13 19:04:44]

Done.

+      return;
   }
 }
 
 void VideoCaptureImpl::StopCapture(int client_id) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   // A client ID can be in only one client list.
   // If this ID is in any client list, we can just remove it from
   // that client list and don't have to run the other following RemoveClient().
   if (!RemoveClient(client_id, &clients_pending_on_restart_)) {
     RemoveClient(client_id, &clients_);
@@ skipping 29 matching lines @@
       base::Bind(&VideoCaptureImpl::OnDeviceFormatsInUse,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void VideoCaptureImpl::OnStateChanged(mojom::VideoCaptureState state) {
   DVLOG(1) << __func__ << " state: " << state;
   DCHECK(io_thread_checker_.CalledOnValidThread());
 
   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.
+      state_ = VIDEO_CAPTURE_STATE_STARTED;
+      for (const auto& client : clients_)
+        client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STARTED);
+      // In case there is any frame dropped before STARTED, always request for
+      // a frame refresh to start the video call with.
+      // Capture device will make a decision if it should refresh a frame.
+      RequestRefreshFrame();
       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_)
@@ skipping 18 matching lines @@
       break;
   }
 }
 
 void VideoCaptureImpl::OnBufferCreated(int32_t buffer_id,
                                        mojo::ScopedSharedBufferHandle handle) {
   DVLOG(1) << __func__ << " buffer_id: " << buffer_id;
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(handle.is_valid());
 
-  if (state_ != VIDEO_CAPTURE_STATE_STARTED)
-    return;
-
   base::SharedMemoryHandle memory_handle;
   size_t memory_size = 0;
   bool read_only_flag = false;
 
   const MojoResult result = mojo::UnwrapSharedMemoryHandle(
       std::move(handle), &memory_handle, &memory_size, &read_only_flag);
   DCHECK_EQ(MOJO_RESULT_OK, result);
   DCHECK_GT(memory_size, 0u);
 
   std::unique_ptr<base::SharedMemory> shm(
@@ skipping 99 matching lines @@
     int buffer_id,
     const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
     double consumer_resource_utilization) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   GetVideoCaptureHost()->ReleaseBuffer(
       device_id_, buffer_id, consumer_resource_utilization);
 }
 
 void VideoCaptureImpl::StopDevice() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
-  if (state_ != VIDEO_CAPTURE_STATE_STARTED)
+  if (state_ != VIDEO_CAPTURE_STATE_STARTING &&
+      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_thread_checker_.CalledOnValidThread());
   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) << __func__ << " " << params_.requested_format.frame_size.ToString();
   StartCaptureInternal();
 }
 
 void VideoCaptureImpl::StartCaptureInternal() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
+  state_ = VIDEO_CAPTURE_STATE_STARTING;
 
   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_thread_checker_.CalledOnValidThread());
   callback.Run(supported_formats);
 }
 
 void VideoCaptureImpl::OnDeviceFormatsInUse(
@@ skipping 33 matching lines @@
   // 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(consumer_resource_utilization);
 }
 
 }  // namespace content