Report if video capturing meets output protection requirement.

chrome/browser/media/media_capture_devices_dispatcher.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 "chrome/browser/media/media_capture_devices_dispatcher.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 48 matching lines @@
   content::MediaStreamDevices::const_iterator iter = devices.begin();
   for (; iter != devices.end(); ++iter) {
     if (iter->id == device_id) {
       return &(*iter);
     }
   }
   return NULL;
 }
 
 #if defined(ENABLE_EXTENSIONS)
 inline DesktopCaptureAccessHandler* ToDesktopCaptureAccessHandler(

[miu, 2016/04/26 01:25:13]

I think you can delete this function now.

[xjz, 2016/04/29 00:11:42]

This is used by |IsDesktopCaptureInProgress()| for now, and will be removed
after output protection switches to use the new API for checking.

[miu, 2016/05/02 21:02:45]

Yes, but can IsDesktopCaptureInProgress() just call ToCaptureAccessHandlerBase()
instead of this function?

[xjz, 2016/05/04 18:23:48]

Done. Actually now changed the OutputProtectionDelegate to call the new API and
removed all unused codes.:)

     MediaAccessHandler* handler) {
   return static_cast<DesktopCaptureAccessHandler*>(handler);
 }
+
+inline CaptureAccessHandlerBase* ToCaptureAccessHandlerBase(
+    MediaAccessHandler* handler) {
+  return static_cast<CaptureAccessHandlerBase*>(handler);
+}
 #endif
 }  // namespace
 
 MediaCaptureDevicesDispatcher* MediaCaptureDevicesDispatcher::GetInstance() {
   return base::Singleton<MediaCaptureDevicesDispatcher>::get();
 }
 
 MediaCaptureDevicesDispatcher::MediaCaptureDevicesDispatcher()
     : is_device_enumeration_disabled_(false),
       media_stream_capture_indicator_(new MediaStreamCaptureIndicator()) {
@@ skipping 296 matching lines @@
   for (MediaAccessHandler* handler : media_access_handlers_) {
     if (handler->SupportsStreamType(content::MEDIA_DESKTOP_VIDEO_CAPTURE,
                                     NULL)) {
       return ToDesktopCaptureAccessHandler(handler)->IsCaptureInProgress();
     }
   }
 #endif
   return false;
 }
 
+bool MediaCaptureDevicesDispatcher::IsInsecureCapturingInProgress(
+    int render_process_id,
+    int render_frame_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+#if defined(ENABLE_EXTENSIONS)
+  for (MediaAccessHandler* handler : media_access_handlers_) {
+    if (handler->SupportsStreamType(content::MEDIA_DESKTOP_VIDEO_CAPTURE,
+                                    nullptr) ||
+        handler->SupportsStreamType(content::MEDIA_TAB_VIDEO_CAPTURE,
+                                    nullptr)) {
+      if (ToCaptureAccessHandlerBase(handler)->IsInsecureCapturingInProgress(
+              render_process_id, render_frame_id))
+        return true;
+    }
+  }
+#endif
+  return false;
+}
+
 void MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices(
     const MediaStreamDevices& devices) {
   test_audio_devices_ = devices;
 }
 
 void MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices(
     const MediaStreamDevices& devices) {
   test_video_devices_ = devices;
 }
+
+void MediaCaptureDevicesDispatcher::OnSetCapturingLinkSecured(
+    int render_process_id,
+    int render_frame_id,
+    int page_request_id,
+    content::MediaStreamType stream_type,
+    bool is_secure) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (stream_type != content::MEDIA_TAB_VIDEO_CAPTURE &&
+      stream_type != content::MEDIA_DESKTOP_VIDEO_CAPTURE)
+    return;
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&MediaCaptureDevicesDispatcher::UpdateCapturingLinkSecured,
+                 base::Unretained(this), render_process_id, render_frame_id,
+                 page_request_id, stream_type, is_secure));
+}
+
+void MediaCaptureDevicesDispatcher::UpdateCapturingLinkSecured(
+    int render_process_id,
+    int render_frame_id,
+    int page_request_id,
+    content::MediaStreamType stream_type,
+    bool is_secure) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (stream_type != content::MEDIA_TAB_VIDEO_CAPTURE &&
+      stream_type != content::MEDIA_DESKTOP_VIDEO_CAPTURE)
+    return;
+
+#if defined(ENABLE_EXTENSIONS)
+  for (MediaAccessHandler* handler : media_access_handlers_) {
+    if (handler->SupportsStreamType(stream_type, nullptr)) {
+      ToCaptureAccessHandlerBase(handler)->UpdateCapturingLinkSecured(
+          render_process_id, render_frame_id, page_request_id, is_secure);
+      break;
+    }
+  }
+#endif
+}