Report if video capturing meets output protection requirement.

chrome/browser/media/media_capture_devices_dispatcher.h

 // 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.
 
 #ifndef CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_
 #define CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_
 
 #include <deque>
 #include <list>
 #include <map>
@@ skipping 119 matching lines @@
   void OnAudioCaptureDevicesChanged() override;
   void OnVideoCaptureDevicesChanged() override;
   void OnMediaRequestStateChanged(int render_process_id,
                                   int render_frame_id,
                                   int page_request_id,
                                   const GURL& security_origin,
                                   content::MediaStreamType stream_type,
                                   content::MediaRequestState state) override;
   void OnCreatingAudioStream(int render_process_id,
                              int render_frame_id) override;
+  void OnSetCapturingLinkSecured(int render_process_id,
+                                 int render_frame_id,
+                                 int page_request_id,
+                                 content::MediaStreamType stream_type,
+                                 bool is_secure) override;
 
   scoped_refptr<MediaStreamCaptureIndicator> GetMediaStreamCaptureIndicator();
 
   DesktopStreamsRegistry* GetDesktopStreamsRegistry();
 
+  // TODO(xjz): remove this after output protection changes to use
+  // |IsCaptureInProgress()| for checking.
   bool IsDesktopCaptureInProgress();
 
+  // Check if any capture is in process, and return if it has secure link in
+  // |is_link_secure|.

[xhwang, 2016/04/12 22:18:50]

We are more interested in whether all links are secure, rather than whether "it
has secure link".

[xjz, 2016/04/12 22:29:08]

Yes. |is_link_secure| is true only when all links connected with this content
are secure. The comment is not accurate. I Will modify it in the next patch.

+  bool IsCaptureInProgress(int render_process_id,
+                           int render_frame_id,
+                           bool* is_link_secure);

[xhwang, 2016/04/12 22:18:49]

Does this cover all capturing cases, e.g. desktop/screen/tab?

[xjz, 2016/04/12 22:29:07]

Yes.

+
   // Only for testing.
   void SetTestAudioCaptureDevices(const content::MediaStreamDevices& devices);
   void SetTestVideoCaptureDevices(const content::MediaStreamDevices& devices);
 
  private:
   friend struct base::DefaultSingletonTraits<MediaCaptureDevicesDispatcher>;
 
   MediaCaptureDevicesDispatcher();
   ~MediaCaptureDevicesDispatcher() override;
 
   // Called by the MediaObserver() functions, executed on UI thread.
   void NotifyAudioDevicesChangedOnUIThread();
   void NotifyVideoDevicesChangedOnUIThread();
   void UpdateMediaRequestStateOnUIThread(
       int render_process_id,
       int render_frame_id,
       int page_request_id,
       const GURL& security_origin,
       content::MediaStreamType stream_type,
       content::MediaRequestState state);
   void OnCreatingAudioStreamOnUIThread(int render_process_id,
                                        int render_frame_id);
+  void UpdateCapturingLinkSecured(int render_process_id,
+                                  int render_frame_id,
+                                  int page_request_id,
+                                  content::MediaStreamType stream_type,
+                                  bool is_secure);
 
   // Only for testing, a list of cached audio capture devices.
   content::MediaStreamDevices test_audio_devices_;
 
   // Only for testing, a list of cached video capture devices.
   content::MediaStreamDevices test_video_devices_;
 
   // A list of observers for the device update notifications.
   base::ObserverList<Observer> observers_;
 
   // Flag used by unittests to disable device enumeration.
   bool is_device_enumeration_disabled_;
 
   scoped_refptr<MediaStreamCaptureIndicator> media_stream_capture_indicator_;
 
   std::unique_ptr<DesktopStreamsRegistry> desktop_streams_registry_;
 
   // Handlers for processing media access requests.
   ScopedVector<MediaAccessHandler> media_access_handlers_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCaptureDevicesDispatcher);
 };
 
 #endif  // CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_