Report if video capturing meets output protection requirement.

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"
@@ skipping 193 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 SetCapturingLinkSecured(bool is_secure) 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_;
 
+  const content::MediaStreamType stream_type_;
+
   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().
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalVideoCapturerSource);
 };
 
 }  // namespace
 
 LocalVideoCapturerSource::LocalVideoCapturerSource(
     const StreamDeviceInfo& device_info)
     : session_id_(device_info.session_id),
+      stream_type_(device_info.device.type),
       manager_(RenderThreadImpl::current()->video_capture_impl_manager()),
       release_device_cb_(manager_->UseDevice(session_id_)),
       is_content_capture_(IsContentVideoCaptureDevice(device_info)),
       weak_factory_(this) {
   DCHECK(RenderThreadImpl::current());
 }
 
 LocalVideoCapturerSource::~LocalVideoCapturerSource() {
   DCHECK(thread_checker_.CalledOnValidThread());
   release_device_cb_.Run();
@@ skipping 48 matching lines @@
 }
 
 void LocalVideoCapturerSource::RequestRefreshFrame() {
   DVLOG(3) << __FUNCTION__;
   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::SetCapturingLinkSecured(bool is_secure) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  manager_->SetCapturingLinkSecured(stream_type_, session_id_, is_secure);
+}
 
 void LocalVideoCapturerSource::StopCapture() {
   DVLOG(3) << __FUNCTION__;
   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();
@@ skipping 74 matching lines @@
   SetDeviceInfo(device_info);
 }
 
 MediaStreamVideoCapturerSource::~MediaStreamVideoCapturerSource() {
 }
 
 void MediaStreamVideoCapturerSource::RequestRefreshFrame() {
   source_->RequestRefreshFrame();
 }
 
+void MediaStreamVideoCapturerSource::SetCapturingLinkSecured(bool is_secure) {
+  source_->SetCapturingLinkSecured(is_secure);
+}
+
 void MediaStreamVideoCapturerSource::GetCurrentSupportedFormats(
     int max_requested_width,
     int max_requested_height,
     double max_requested_frame_rate,
     const VideoCaptureDeviceFormatsCB& callback) {
   source_->GetCurrentSupportedFormats(
       max_requested_width,
       max_requested_height,
       max_requested_frame_rate,
       callback);
@@ skipping 25 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