content/browser/renderer_host/media/media_stream_ui_proxy_unittest.cc

   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 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
   6
   7 #include "base/message_loop.h"
   8 #include "content/browser/renderer_host/render_view_host_delegate.h"
   9 #include "content/public/common/renderer_preferences.h"
  10 #include "content/public/test/test_browser_thread.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "ui/gfx/rect.h"
  14
  15 using testing::_;
  16 using testing::SaveArg;
  17
  18 namespace content {
  19 namespace {
  20
  21 class MockRenderViewHostDelegate : public RenderViewHostDelegate {
  22  public:
  23   MOCK_METHOD2(RequestMediaAccessPermission,
  24                void(const MediaStreamRequest& request,
  25                     const MediaResponseCallback& callback));
  26
  27   // Stubs for pure virtual methods we don't care about.
  28   virtual gfx::Rect GetRootWindowResizerRect() const OVERRIDE {
  29     NOTREACHED();
  30     return gfx::Rect();
  31   }
  32   virtual RendererPreferences GetRendererPrefs(
  33       BrowserContext* browser_context) const OVERRIDE {
  34     NOTREACHED();
  35     return RendererPreferences();
  36   }
  37 };
  38
  39 class MockResponseCallback {
  40  public:
  41   MOCK_METHOD1(OnAccessRequestResponse,
  42                void(const MediaStreamDevices& devices));
  43 };
  44
  45 class MockMediaStreamUI : public MediaStreamUI {
  46  public:
  47   MOCK_METHOD1(OnStarted, void(const base::Closure& stop));
  48 };
  49
  50 class MockStopStreamHandler {
  51  public:
  52   MOCK_METHOD0(OnStop, void());
  53 };
  54
  55
  56 }  // namespace
  57
  58 class MediaStreamUIProxyTest : public testing::Test {
  59  public:
  60   MediaStreamUIProxyTest()
  61       : ui_thread_(BrowserThread::UI, &message_loop_),
  62         io_thread_(BrowserThread::IO, &message_loop_) {
  63     proxy_ = MediaStreamUIProxy::CreateForTests(&delegate_);
  64   }
  65
  66   virtual ~MediaStreamUIProxyTest() {
  67     proxy_.reset();
  68     message_loop_.RunUntilIdle();
  69   }
  70
  71  protected:
  72   base::MessageLoop message_loop_;
  73   TestBrowserThread ui_thread_;
  74   TestBrowserThread io_thread_;
  75
  76   MockRenderViewHostDelegate delegate_;
  77   MockResponseCallback response_callback_;
  78   scoped_ptr<MediaStreamUIProxy> proxy_;
  79 };
  80
  81 MATCHER_P(SameRequest, expected, "") {
  82   return
  83     expected.render_process_id == arg.render_process_id &&
  84     expected.render_view_id == arg.render_view_id &&
  85     expected.security_origin == arg.security_origin &&
  86     expected.request_type == arg.request_type &&
  87     expected.requested_device_id == arg.requested_device_id &&
  88     expected.audio_type == arg.audio_type &&
  89     expected.video_type == arg.video_type;
  90 }
  91
  92 TEST_F(MediaStreamUIProxyTest, Deny) {
  93   MediaStreamRequest request(0, 0, GURL("http://origin/"),
  94                              MEDIA_GENERATE_STREAM, std::string(),
  95                              MEDIA_DEVICE_AUDIO_CAPTURE,
  96                              MEDIA_DEVICE_VIDEO_CAPTURE);
  97   proxy_->RequestAccess(
  98       request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
  99                           base::Unretained(&response_callback_)));
 100   MediaResponseCallback callback;
 101   EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
 102     .WillOnce(SaveArg<1>(&callback));
 103   message_loop_.RunUntilIdle();
 104   ASSERT_FALSE(callback.is_null());
 105
 106   MediaStreamDevices devices;
 107   callback.Run(devices, scoped_ptr<MediaStreamUI>());
 108
 109   MediaStreamDevices response;
 110   EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
 111     .WillOnce(SaveArg<0>(&response));
 112   message_loop_.RunUntilIdle();
 113
 114   EXPECT_TRUE(response.empty());
 115 }
 116
 117 TEST_F(MediaStreamUIProxyTest, AcceptAndStart) {
 118   MediaStreamRequest request(0, 0, GURL("http://origin/"),
 119                              MEDIA_GENERATE_STREAM, std::string(),
 120                              MEDIA_DEVICE_AUDIO_CAPTURE,
 121                              MEDIA_DEVICE_VIDEO_CAPTURE);
 122   proxy_->RequestAccess(
 123       request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
 124                           base::Unretained(&response_callback_)));
 125   MediaResponseCallback callback;
 126   EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
 127     .WillOnce(SaveArg<1>(&callback));
 128   message_loop_.RunUntilIdle();
 129   ASSERT_FALSE(callback.is_null());
 130
 131   MediaStreamDevices devices;
 132   devices.push_back(
 133       MediaStreamDevice(MEDIA_DEVICE_AUDIO_CAPTURE, "Mic", "Mic"));
 134   scoped_ptr<MockMediaStreamUI> ui(new MockMediaStreamUI());
 135   EXPECT_CALL(*ui, OnStarted(_));
 136   callback.Run(devices, ui.PassAs<MediaStreamUI>());
 137
 138   MediaStreamDevices response;
 139   EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
 140     .WillOnce(SaveArg<0>(&response));
 141   message_loop_.RunUntilIdle();
 142
 143   EXPECT_FALSE(response.empty());
 144
 145   proxy_->OnStarted(base::Closure());
 146   message_loop_.RunUntilIdle();
 147 }
 148
 149 // Verify that the proxy can be deleted before the request is processed.
 150 TEST_F(MediaStreamUIProxyTest, DeleteBeforeAccepted) {
 151   MediaStreamRequest request(0, 0, GURL("http://origin/"),
 152                              MEDIA_GENERATE_STREAM, std::string(),
 153                              MEDIA_DEVICE_AUDIO_CAPTURE,
 154                              MEDIA_DEVICE_VIDEO_CAPTURE);
 155   proxy_->RequestAccess(
 156       request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
 157                           base::Unretained(&response_callback_)));
 158   MediaResponseCallback callback;
 159   EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
 160     .WillOnce(SaveArg<1>(&callback));
 161   message_loop_.RunUntilIdle();
 162   ASSERT_FALSE(callback.is_null());
 163
 164   proxy_.reset();
 165
 166   MediaStreamDevices devices;
 167   scoped_ptr<MediaStreamUI> ui;
 168   callback.Run(devices, ui.Pass());
 169 }
 170
 171 TEST_F(MediaStreamUIProxyTest, StopFromUI) {
 172   MediaStreamRequest request(0, 0, GURL("http://origin/"),
 173                              MEDIA_GENERATE_STREAM, std::string(),
 174                              MEDIA_DEVICE_AUDIO_CAPTURE,
 175                              MEDIA_DEVICE_VIDEO_CAPTURE);
 176   proxy_->RequestAccess(
 177       request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
 178                           base::Unretained(&response_callback_)));
 179   MediaResponseCallback callback;
 180   EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
 181     .WillOnce(SaveArg<1>(&callback));
 182   message_loop_.RunUntilIdle();
 183   ASSERT_FALSE(callback.is_null());
 184
 185   base::Closure stop_callback;
 186
 187   MediaStreamDevices devices;
 188   devices.push_back(
 189       MediaStreamDevice(MEDIA_DEVICE_AUDIO_CAPTURE, "Mic", "Mic"));
 190   scoped_ptr<MockMediaStreamUI> ui(new MockMediaStreamUI());
 191   EXPECT_CALL(*ui, OnStarted(_))
 192       .WillOnce(SaveArg<0>(&stop_callback));
 193   callback.Run(devices, ui.PassAs<MediaStreamUI>());
 194
 195   MediaStreamDevices response;
 196   EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
 197     .WillOnce(SaveArg<0>(&response));
 198   message_loop_.RunUntilIdle();
 199
 200   EXPECT_FALSE(response.empty());
 201
 202   MockStopStreamHandler stop_handler;
 203   proxy_->OnStarted(base::Bind(&MockStopStreamHandler::OnStop,
 204                                base::Unretained(&stop_handler)));
 205   message_loop_.RunUntilIdle();
 206
 207   ASSERT_FALSE(stop_callback.is_null());
 208   EXPECT_CALL(stop_handler, OnStop());
 209   stop_callback.Run();
 210   message_loop_.RunUntilIdle();
 211 }
 212
 213 }  // content