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"
 #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"
 #include "media/base/video_capturer_source.h"
 #include "media/base/video_frame.h"
 
 namespace content {
@@ skipping 287 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::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 54 matching lines @@
           gfx::Size(resolution.width, resolution.height), frame_rate,
           media::PIXEL_FORMAT_I420));
     }
   }
   base::ResetAndReturn(&formats_enumerated_callback_).Run(default_formats);
 }
 
 MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
     const SourceStoppedCallback& stop_callback,
     std::unique_ptr<media::VideoCapturerSource> source)
-    : source_(std::move(source)) {
+    : source_(std::move(source)), render_frame_(nullptr) {
   SetStopCallback(stop_callback);
 }
 
 MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
     const SourceStoppedCallback& stop_callback,
-    const StreamDeviceInfo& device_info)
-    : source_(new LocalVideoCapturerSource(device_info)) {
+    const StreamDeviceInfo& device_info,
+    RenderFrame* render_frame)
+    : source_(new LocalVideoCapturerSource(device_info)),
+      render_frame_(render_frame) {
   SetStopCallback(stop_callback);
   SetDeviceInfo(device_info);
 }
 
 MediaStreamVideoCapturerSource::~MediaStreamVideoCapturerSource() {
 }
 
 void MediaStreamVideoCapturerSource::RequestRefreshFrame() {
   source_->RequestRefreshFrame();
 }
 
+void MediaStreamVideoCapturerSource::SetCapturingLinkSecured(bool is_secure) {
+  if (render_frame_) {

[miu, 2016/05/06 18:56:22]

If this class extends RenderFrameObserver, all the code in this method becomes:

  Send(new MediaStreamHostMsg_...);

(Since RenderFrameObserver provides a Send() method that null-checks the
RenderFrame for you.)

[xjz, 2016/05/06 22:08:45]

Done.

+    render_frame_->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(
       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