Check media permissions through RenderFrameHostDelegate.

content/browser/renderer_host/media/media_stream_ui_proxy.h

 // Copyright 2013 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 CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_UI_PROXY_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_UI_PROXY_H_
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 23 matching lines @@
 
   virtual ~MediaStreamUIProxy();
 
   // Requests access for the MediaStream by calling
   // WebContentsDelegate::RequestMediaAccessPermission(). The specified
   // |response_callback| is called when the WebContentsDelegate approves or
   // denies request.
   virtual void RequestAccess(const MediaStreamRequest& request,
                              const ResponseCallback& response_callback);
 
+  // Checks if we have permission to access the microphone or camera. Note that
+  // this does not query the user. |type| must be MEDIA_DEVICE_AUDIO_CAPTURE

[perkj_chrome, 2014/09/15 12:06:25]

Can you expand this. Ie, When should this be called and what does it mean that
this returns true or false? Ie, does false mean we should ask the user for
permission?

[Henrik Grunell, 2014/09/15 13:45:17]

I added that this checks any stored settings. Not sure how to explain further.
What to do with the result depends on who called it and why. The only use case
now is device enumeration; we just want to know if there's permission granted or
not.

[perkj_chrome, 2014/09/15 15:08:55]

I was wondering about the " Note that
  45   // this does not query the user" part. What is it that make this return
true? |security_origin| has been granted access before by a user gesture? Or
since its an packaged app with the correct permissions? 

[Henrik Grunell, 2014/09/15 18:20:15]

Yes, exactly. Either if the user has granted access before and it's stored in
the content settings, or the policy allows it, or the packaged app contains the
permission. It's exactly the same as for RequestAccess above, but without asking
the user.

+  // or MEDIA_DEVICE_VIDEO_CAPTURE.
+  virtual void CheckAccess(const GURL& security_origin,
+                           MediaStreamType type,
+                           int render_process_id,
+                           int render_frame_id,
+                           const base::Callback<void(bool)>& callback);
+
   // Notifies the UI that the MediaStream has been started. Must be called after
   // access has been approved using RequestAccess(). |stop_callback| is be
   // called on the IO thread after the user has requests the stream to be
   // stopped. |window_id_callback| is called on the IO thread with the platform-
   // dependent window ID of the UI.
   virtual void OnStarted(const base::Closure& stop_callback,
                          const WindowIdCallback& window_id_callback);
 
   void SetRenderFrameHostDelegateForTests(RenderFrameHostDelegate* delegate);
 
  protected:
   explicit MediaStreamUIProxy(RenderFrameHostDelegate* test_render_delegate);
 
  private:
   class Core;
   friend class Core;
   friend class FakeMediaStreamUIProxy;
 
   void ProcessAccessRequestResponse(
       const MediaStreamDevices& devices,
       content::MediaStreamRequestResult result);
   void ProcessStopRequestFromUI();
   void OnWindowId(const WindowIdCallback& window_id_callback,
                   gfx::NativeViewId* window_id);
+  void OnCheckedAccess(const base::Callback<void(bool)>& callback,
+                       bool have_access);
 
   scoped_ptr<Core, content::BrowserThread::DeleteOnUIThread> core_;
   ResponseCallback response_callback_;
   base::Closure stop_callback_;
 
   base::WeakPtrFactory<MediaStreamUIProxy> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamUIProxy);
 };
 
 class CONTENT_EXPORT FakeMediaStreamUIProxy : public MediaStreamUIProxy {
  public:
   explicit FakeMediaStreamUIProxy();
   virtual ~FakeMediaStreamUIProxy();
 
   void SetAvailableDevices(const MediaStreamDevices& devices);
+  void SetMicAccess(bool access);
+  void SetCameraAccess(bool access);
 
   // MediaStreamUIProxy overrides.
   virtual void RequestAccess(
       const MediaStreamRequest& request,
       const ResponseCallback& response_callback) OVERRIDE;
+  virtual void CheckAccess(const GURL& security_origin,
+                           MediaStreamType type,
+                           int render_process_id,
+                           int render_frame_id,
+                           const base::Callback<void(bool)>& callback) OVERRIDE;
   virtual void OnStarted(const base::Closure& stop_callback,
                          const WindowIdCallback& window_id_callback) OVERRIDE;
 
  private:
+  // This is used for RequestAccess().
   MediaStreamDevices devices_;
 
+  // These are used for CheckAccess().
+  bool mic_access_;
+  bool camera_access_;
+
   DISALLOW_COPY_AND_ASSIGN(FakeMediaStreamUIProxy);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_UI_PROXY_H_