Check all settings when checking mic and camera access

content/browser/renderer_host/media/media_stream_manager.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.
 
 // MediaStreamManager is used to open/enumerate media capture devices (video
 // supported now). Call flow:
 // 1. GenerateStream is called when a render process wants to use a capture
 //    device.
 // 2. MediaStreamManager will ask MediaStreamUIController for permission to
 //    use devices and for which device to use.
@@ skipping 32 matching lines @@
 #include "content/public/browser/media_request_state.h"
 #include "content/public/browser/resource_context.h"
 
 namespace media {
 class AudioManager;
 }
 
 namespace content {
 
 class AudioInputDeviceManager;
+class BrowserContext;
 class FakeMediaStreamUIProxy;
 class MediaStreamDeviceSettings;
 class MediaStreamRequester;
 class MediaStreamUIProxy;
 class VideoCaptureManager;
 
 // MediaStreamManager is used to generate and close new media devices, not to
 // start the media flow. The classes requesting new media streams are answered
 // using MediaStreamRequester.
 class CONTENT_EXPORT MediaStreamManager
@@ skipping 59 matching lines @@
                         int render_frame_id,
                         const std::string& device_id);
 
   // Gets a list of devices of |type|, which must be MEDIA_DEVICE_AUDIO_CAPTURE
   // or MEDIA_DEVICE_VIDEO_CAPTURE.
   // The request is identified using the string returned to the caller.
   // When the |requester| is NULL, MediaStreamManager will enumerate both audio
   // and video devices and also start monitoring device changes, such as
   // plug/unplug. The new device lists will be delivered via media observer to
   // MediaCaptureDevicesDispatcher.
-  // If |have_permission| is false, we remove the device label from the result.
   virtual std::string EnumerateDevices(MediaStreamRequester* requester,
                                        int render_process_id,
                                        int render_frame_id,
                                        const ResourceContext::SaltCallback& sc,
                                        int page_request_id,
                                        MediaStreamType type,
-                                       const GURL& security_origin,
-                                       bool have_permission);
+                                       const GURL& security_origin);
 
   // Open a device identified by |device_id|.  |type| must be either
   // MEDIA_DEVICE_AUDIO_CAPTURE or MEDIA_DEVICE_VIDEO_CAPTURE.
   // The request is identified using string returned to the caller.
   void OpenDevice(MediaStreamRequester* requester,
                   int render_process_id,
                   int render_frame_id,
                   const ResourceContext::SaltCallback& sc,
                   int page_request_id,
                   const std::string& device_id,
@@ skipping 165 matching lines @@
                              DeviceRequest* request,
                              content::MediaStreamRequestResult result);
   void FinalizeOpenDevice(const std::string& label,
                           DeviceRequest* request);
   void FinalizeMediaAccessRequest(const std::string& label,
                                   DeviceRequest* request,
                                   const MediaStreamDevices& devices);
   void FinalizeEnumerateDevices(const std::string& label,
                                 DeviceRequest* request);
 
+  // Checks for media access. Overridden by unit tests.

[perkj_chrome, 2014/08/28 15:09:40]

media device permissions?

[Henrik Grunell, 2014/08/29 07:59:10]

We have e.g. HandleAccessRequestResponse and FinalizeMediaAccessRequest, so I
chose the name to be in line with that. I'd prefer to stick to the current
naming convention. (It's also in other places like RenderFrameHostDelegate.)

+  virtual bool CheckMediaAccessOnUI(int render_process_id,
+                                    const GURL& security_origin,
+                                    MediaStreamType type);
+  void HandleCheckMediaAccessResponse(const std::string& label,
+                                      bool have_access);
+
   // This method is called when an audio or video device is plugged in or
   // removed. It make sure all MediaStreams that use a removed device is
   // stopped and that the render process is notified. |old_devices| is the list
   // of previously available devices. |new_devices| is the new
   // list of currently available devices.
   void StopRemovedDevices(const StreamDeviceInfoArray& old_devices,
                           const StreamDeviceInfoArray& new_devices);
   // Helper method used by StopRemovedDevices to stop the use of a certain
   // device.
   void StopRemovedDevice(const MediaStreamDevice& device);
@@ skipping 57 matching lines @@
 
   bool use_fake_ui_;
   scoped_ptr<FakeMediaStreamUIProxy> fake_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_