Video Capture: Allow suspension of individual devices.

content/renderer/media/media_stream_video_capturer_source.cc

 // Copyright 2014 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/renderer/media/media_stream_video_capturer_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/debug/stack_trace.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
@@ skipping 184 matching lines @@
   // VideoCaptureDelegate Implementation.
   void GetCurrentSupportedFormats(
       int max_requested_width,
       int max_requested_height,
       double max_requested_frame_rate,
       const VideoCaptureDeviceFormatsCB& callback) override;
   void StartCapture(const media::VideoCaptureParams& params,
                     const VideoCaptureDeliverFrameCB& new_frame_callback,
                     const RunningCallback& running_callback) override;
   void RequestRefreshFrame() override;
+  void MaybeSuspend() override;
+  void Resume() override;
   void StopCapture() override;
 
  private:
   void OnStateUpdate(VideoCaptureState state);
   void OnDeviceFormatsInUseReceived(const media::VideoCaptureFormats& formats);
   void OnDeviceSupportedFormatsEnumerated(
       const media::VideoCaptureFormats& formats);
 
   // |session_id_| identifies the capture device used for this capture session.
   const media::VideoCaptureSessionId session_id_;
 
   VideoCaptureImplManager* const manager_;
 
   const base::Closure release_device_cb_;
 
   // Indicates if we are capturing generated content, e.g. Tab or Desktop.
   const bool is_content_capture_;
 
-  // These two are valid between StartCapture() and StopCapture().
+  // This is run once to report whether the device was successfully started
+  // after a call to StartCapture().
+  RunningCallback running_callback_;
+
+  // This is valid between StartCapture() and StopCapture().
   base::Closure stop_capture_cb_;
-  RunningCallback running_callback_;
 
   // Placeholder keeping the callback between asynchronous device enumeration
   // calls.
   VideoCaptureDeviceFormatsCB formats_enumerated_callback_;
 
   // Bound to the main render thread.
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<LocalVideoCapturerSource> weak_factory_;
 
@@ skipping 66 matching lines @@
 }
 
 void LocalVideoCapturerSource::RequestRefreshFrame() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (stop_capture_cb_.is_null())
     return;  // Do not request frames if the source is stopped.
   manager_->RequestRefreshFrame(session_id_);
 }
 
+void LocalVideoCapturerSource::MaybeSuspend() {
+  DVLOG(3) << __func__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  manager_->Suspend(session_id_);
+}
+
+void LocalVideoCapturerSource::Resume() {
+  DVLOG(3) << __func__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  manager_->Resume(session_id_);
+}
+
 void LocalVideoCapturerSource::StopCapture() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   // Immediately make sure we don't provide more frames.
   if (!stop_capture_cb_.is_null())
     base::ResetAndReturn(&stop_capture_cb_).Run();
   running_callback_.Reset();
   // Invalidate any potential format enumerations going on.
   formats_enumerated_callback_.Reset();
 }
 
 void LocalVideoCapturerSource::OnStateUpdate(VideoCaptureState state) {
   DVLOG(3) << __func__ << " state = " << state;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (running_callback_.is_null())
     return;
-  const bool is_started_ok = state == VIDEO_CAPTURE_STATE_STARTED;
-  running_callback_.Run(is_started_ok);
-  if (!is_started_ok)
-    running_callback_.Reset();
+  switch (state) {
+    case VIDEO_CAPTURE_STATE_STARTED:
+      base::ResetAndReturn(&running_callback_).Run(true);
+      break;
+
+    case VIDEO_CAPTURE_STATE_STOPPING:
+    case VIDEO_CAPTURE_STATE_STOPPED:
+    case VIDEO_CAPTURE_STATE_ERROR:
+    case VIDEO_CAPTURE_STATE_ENDED:
+      base::ResetAndReturn(&running_callback_).Run(false);
+      break;
+
+    case VIDEO_CAPTURE_STATE_STARTING:
+    case VIDEO_CAPTURE_STATE_PAUSED:
+    case VIDEO_CAPTURE_STATE_RESUMED:
+      // Not applicable to reporting on device start success/failure.
+      break;
+  }
 }
 
 void LocalVideoCapturerSource::OnDeviceFormatsInUseReceived(
     const media::VideoCaptureFormats& formats_in_use) {
   DVLOG(3) << __func__ << ", #formats received: " << formats_in_use.size();
   DCHECK(thread_checker_.CalledOnValidThread());
   // StopCapture() might have destroyed |formats_enumerated_callback_| before
   // arriving here.
   if (formats_enumerated_callback_.is_null())
     return;
@@ skipping 55 matching lines @@
   SetDeviceInfo(device_info);
 }
 
 MediaStreamVideoCapturerSource::~MediaStreamVideoCapturerSource() {
 }
 
 void MediaStreamVideoCapturerSource::RequestRefreshFrame() {
   source_->RequestRefreshFrame();
 }
 
-void MediaStreamVideoCapturerSource::SetCapturingLinkSecured(bool is_secure) {
+void MediaStreamVideoCapturerSource::OnHasConsumers(bool has_consumers) {
+  if (has_consumers)
+    source_->Resume();
+  else
+    source_->MaybeSuspend();
+}
+
+void MediaStreamVideoCapturerSource::OnCapturingLinkSecured(bool is_secure) {
   Send(new MediaStreamHostMsg_SetCapturingLinkSecured(
       device_info().session_id, device_info().device.type, is_secure));
 }
 
 void MediaStreamVideoCapturerSource::GetCurrentSupportedFormats(
     int max_requested_width,
     int max_requested_height,
     double max_requested_frame_rate,
     const VideoCaptureDeviceFormatsCB& callback) {
   source_->GetCurrentSupportedFormats(
@@ skipping 29 matching lines @@
 void MediaStreamVideoCapturerSource::OnStarted(bool result) {
   OnStartDone(result ? MEDIA_DEVICE_OK : MEDIA_DEVICE_TRACK_START_FAILURE);
 }
 
 const char*
 MediaStreamVideoCapturerSource::GetPowerLineFrequencyForTesting() const {
   return kPowerLineFrequency;
 }
 
 }  // namespace content