content/browser/renderer_host/media/media_stream_ui_proxy.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_UI_PROXY_H_
   6 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_UI_PROXY_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/callback.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "content/public/browser/browser_thread.h"
  13 #include "content/public/common/media_stream_request.h"
  14
  15 namespace content {
  16
  17 class RenderFrameHostDelegate;
  18
  19 // MediaStreamUIProxy proxies calls to media stream UI between IO thread and UI
  20 // thread. One instance of this class is create per MediaStream object. It must
  21 // be created, used and destroyed on IO thread.
  22 class CONTENT_EXPORT MediaStreamUIProxy {
  23  public:
  24   typedef base::Callback<
  25       void (const MediaStreamDevices& devices,
  26             content::MediaStreamRequestResult result)>
  27         ResponseCallback;
  28
  29   typedef base::Callback<void(gfx::NativeViewId window_id)> WindowIdCallback;
  30
  31   static scoped_ptr<MediaStreamUIProxy> Create();
  32   static scoped_ptr<MediaStreamUIProxy> CreateForTests(
  33       RenderFrameHostDelegate* render_delegate);
  34
  35   virtual ~MediaStreamUIProxy();
  36
  37   // Requests access for the MediaStream by calling
  38   // WebContentsDelegate::RequestMediaAccessPermission(). The specified
  39   // |response_callback| is called when the WebContentsDelegate approves or
  40   // denies request.
  41   virtual void RequestAccess(scoped_ptr<MediaStreamRequest> request,
  42                              const ResponseCallback& response_callback);
  43
  44   // Checks if we have permission to access the microphone or camera. Note that
  45   // this does not query the user, it checks any stored settings such as policy
  46   // or extension permissions. |type| must be MEDIA_DEVICE_AUDIO_CAPTURE
  47   // or MEDIA_DEVICE_VIDEO_CAPTURE.
  48   virtual void CheckAccess(const GURL& security_origin,
  49                            MediaStreamType type,
  50                            int render_process_id,
  51                            int render_frame_id,
  52                            const base::Callback<void(bool)>& callback);
  53
  54   // Notifies the UI that the MediaStream has been started. Must be called after
  55   // access has been approved using RequestAccess(). |stop_callback| is be
  56   // called on the IO thread after the user has requests the stream to be
  57   // stopped. |window_id_callback| is called on the IO thread with the platform-
  58   // dependent window ID of the UI.
  59   virtual void OnStarted(const base::Closure& stop_callback,
  60                          const WindowIdCallback& window_id_callback);
  61
  62   void SetRenderFrameHostDelegateForTests(RenderFrameHostDelegate* delegate);
  63
  64  protected:
  65   explicit MediaStreamUIProxy(RenderFrameHostDelegate* test_render_delegate);
  66
  67  private:
  68   class Core;
  69   friend class Core;
  70   friend class FakeMediaStreamUIProxy;
  71
  72   void ProcessAccessRequestResponse(
  73       const MediaStreamDevices& devices,
  74       content::MediaStreamRequestResult result);
  75   void ProcessStopRequestFromUI();
  76   void OnWindowId(const WindowIdCallback& window_id_callback,
  77                   gfx::NativeViewId* window_id);
  78   void OnCheckedAccess(const base::Callback<void(bool)>& callback,
  79                        bool have_access);
  80
  81   scoped_ptr<Core, content::BrowserThread::DeleteOnUIThread> core_;
  82   ResponseCallback response_callback_;
  83   base::Closure stop_callback_;
  84
  85   base::WeakPtrFactory<MediaStreamUIProxy> weak_factory_;
  86
  87   DISALLOW_COPY_AND_ASSIGN(MediaStreamUIProxy);
  88 };
  89
  90 class CONTENT_EXPORT FakeMediaStreamUIProxy : public MediaStreamUIProxy {
  91  public:
  92   explicit FakeMediaStreamUIProxy();
  93   ~FakeMediaStreamUIProxy() override;
  94
  95   void SetAvailableDevices(const MediaStreamDevices& devices);
  96   void SetMicAccess(bool access);
  97   void SetCameraAccess(bool access);
  98
  99   // MediaStreamUIProxy overrides.
 100   void RequestAccess(scoped_ptr<MediaStreamRequest> request,
 101                      const ResponseCallback& response_callback) override;
 102   void CheckAccess(const GURL& security_origin,
 103                    MediaStreamType type,
 104                    int render_process_id,
 105                    int render_frame_id,
 106                    const base::Callback<void(bool)>& callback) override;
 107   void OnStarted(const base::Closure& stop_callback,
 108                  const WindowIdCallback& window_id_callback) override;
 109
 110  private:
 111   // This is used for RequestAccess().
 112   MediaStreamDevices devices_;
 113
 114   // These are used for CheckAccess().
 115   bool mic_access_;
 116   bool camera_access_;
 117
 118   DISALLOW_COPY_AND_ASSIGN(FakeMediaStreamUIProxy);
 119 };
 120
 121 }  // namespace content
 122
 123 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_UI_PROXY_H_