Report if video capturing meets output protection requirement.

content/browser/renderer_host/media/media_stream_manager.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/media_stream_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <cctype>
@@ skipping 294 matching lines @@
 
     media_observer->OnMediaRequestStateChanged(
         target_process_id_, target_frame_id_, page_request_id, security_origin,
         stream_type, new_state);
   }
 
   MediaRequestState state(MediaStreamType stream_type) const {
     return state_[stream_type];
   }
 
+  void SetCapturingLinkSecured(bool is_secure) {
+    MediaObserver* media_observer =
+        GetContentClient()->browser()->GetMediaObserver();
+    if (!media_observer)
+      return;
+
+    media_observer->OnSetCapturingLinkSecured(target_process_id_,
+                                              target_frame_id_, page_request_id,
+                                              video_type_, is_secure);
+  }
+
   MediaStreamRequester* const requester;  // Can be NULL.
 
 
   // The render process id that requested this stream to be generated and that
   // will receive a handle to the MediaStream. This may be different from
   // MediaStreamRequest::render_process_id which in the tab capture case
   // specifies the target renderer from which audio and video is captured.
   const int requesting_process_id;
 
   // The render frame id that requested this stream to be generated and that
@@ skipping 1786 matching lines @@
     const GURL& security_origin,
     const std::string& device_guid,
     const std::string& raw_unique_id) {
   DCHECK(security_origin.is_valid());
   DCHECK(!raw_unique_id.empty());
   std::string guid_from_raw_device_id =
       GetHMACForMediaDeviceID(sc, security_origin, raw_unique_id);
   return guid_from_raw_device_id == device_guid;
 }
 
+void MediaStreamManager::SetCapturingLinkSecured(content::MediaStreamType type,
+                                                 int session_id,
+                                                 bool is_secure) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  for (LabeledDeviceRequest labeled_request : requests_) {

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

s/LabeledDeviceRequest/const LabeledDeviceRequest&/  (to avoid making a copy)

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

Done.

+    DeviceRequest* request = labeled_request.second;
+    for (const StreamDeviceInfo& device_info : request->devices) {
+      if (device_info.session_id == session_id &&
+          device_info.device.type == type) {
+        request->SetCapturingLinkSecured(is_secure);
+      }
+    }
+  }
+}
+
 }  // namespace content