getUserMeida: report device starting states

content/browser/renderer_host/media/video_capture_host.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.
 
 #include "content/browser/renderer_host/media/video_capture_host.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 100 matching lines @@
 
 void VideoCaptureHost::OnEnded(VideoCaptureControllerID controller_id) {
   DVLOG(1) << __func__;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureHost::DoEnded, weak_factory_.GetWeakPtr(),
                  controller_id));
 }
 
+// OnStarted can be forwarded directly, while OnError&OnEnded need to be
+// scheduled to the end of message queue to guarantee some other clearing jobs
+// are done before they are handled.
+void VideoCaptureHost::OnStarted(VideoCaptureControllerID controller_id) {

[chfremer, 2017/02/16 01:00:50]

Thanks. This piece of information is very useful to readers of the code.

We could make it even more useful by placing it in a better location.
A comment here will only be found by readers of the implementation of
OnStarted().
However, the information actually seems to be a crucial part of the contract
between VideoCaptureHost and VideoCaptureController. It basically says that
implementations of OnStarted() are required to handle OnError() and OnEnded()
asynchronously (and bad things will happen if they don't).
The best location for this information would be in
video_capture_controller_event_handler.h.

[braveyao, 2017/02/17 20:37:21]

Done.

+  DVLOG(1) << __func__;
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (controllers_.find(controller_id) == controllers_.end())
+    return;
+
+  if (base::ContainsKey(device_id_to_observer_map_, controller_id)) {
+    device_id_to_observer_map_[controller_id]->OnStateChanged(
+        mojom::VideoCaptureState::STARTED);
+  }
+}
+
 void VideoCaptureHost::Start(int32_t device_id,
                              int32_t session_id,
                              const media::VideoCaptureParams& params,
                              mojom::VideoCaptureObserverPtr observer) {
   DVLOG(1) << __func__ << " session_id=" << session_id
            << ", device_id=" << device_id << ", format="
            << media::VideoCaptureFormat::ToString(params.requested_format);
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   DCHECK(!base::ContainsKey(device_id_to_observer_map_, device_id));
@@ skipping 168 matching lines @@
 
   if (!controller) {
     if (base::ContainsKey(device_id_to_observer_map_, controller_id)) {
       device_id_to_observer_map_[device_id]->OnStateChanged(
           mojom::VideoCaptureState::FAILED);
     }
     controllers_.erase(controller_id);
     return;
   }
 
-  if (base::ContainsKey(device_id_to_observer_map_, controller_id)) {
-    device_id_to_observer_map_[device_id]->OnStateChanged(
-        mojom::VideoCaptureState::STARTED);
-  }
-
   DCHECK(!it->second);
   it->second = controller;
 }
 
 void VideoCaptureHost::DeleteVideoCaptureController(
     VideoCaptureControllerID controller_id, bool on_error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   auto it = controllers_.find(controller_id);
   if (it == controllers_.end())
     return;
 
   const base::WeakPtr<VideoCaptureController> controller = it->second;
   controllers_.erase(it);
   if (!controller)
     return;
 
   media_stream_manager_->video_capture_manager()->StopCaptureForClient(
       controller.get(), controller_id, this, on_error);
 }
 
 }  // namespace content