src/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/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.tab_capture_device_id == arg.tab_capture_device_id &&
  86     expected.security_origin == arg.security_origin &&
  87     expected.request_type == arg.request_type &&
  88     expected.requested_audio_device_id == arg.requested_audio_device_id &&
  89     expected.requested_video_device_id == arg.requested_video_device_id &&
  90     expected.audio_type == arg.audio_type &&
  91     expected.video_type == arg.video_type;
  92 }
  93
  94 TEST_F(MediaStreamUIProxyTest, Deny) {
  95   MediaStreamRequest request(0, 0, 0, std::string(), GURL("http://origin/"),
  96                              MEDIA_GENERATE_STREAM, std::string(),
  97                              std::string(),
  98                              MEDIA_DEVICE_AUDIO_CAPTURE,
  99                              MEDIA_DEVICE_VIDEO_CAPTURE);
 100   proxy_->RequestAccess(
 101       request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
 102                           base::Unretained(&response_callback_)));
 103   MediaResponseCallback callback;
 104   EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
 105     .WillOnce(SaveArg<1>(&callback));
 106   message_loop_.RunUntilIdle();
 107   ASSERT_FALSE(callback.is_null());
 108
 109   MediaStreamDevices devices;
 110   callback.Run(devices, scoped_ptr<MediaStreamUI>());
 111
 112   MediaStreamDevices response;
 113   EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
 114     .WillOnce(SaveArg<0>(&response));
 115   message_loop_.RunUntilIdle();
 116
 117   EXPECT_TRUE(response.empty());
 118 }
 119
 120 TEST_F(MediaStreamUIProxyTest, AcceptAndStart) {
 121   MediaStreamRequest request(0, 0, 0, std::string(), GURL("http://origin/"),
 122                              MEDIA_GENERATE_STREAM, std::string(),
 123                              std::string(),
 124                              MEDIA_DEVICE_AUDIO_CAPTURE,
 125                              MEDIA_DEVICE_VIDEO_CAPTURE);
 126   proxy_->RequestAccess(
 127       request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
 128                           base::Unretained(&response_callback_)));
 129   MediaResponseCallback callback;
 130   EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
 131     .WillOnce(SaveArg<1>(&callback));
 132   message_loop_.RunUntilIdle();
 133   ASSERT_FALSE(callback.is_null());
 134
 135   MediaStreamDevices devices;
 136   devices.push_back(
 137       MediaStreamDevice(MEDIA_DEVICE_AUDIO_CAPTURE, "Mic", "Mic"));
 138   scoped_ptr<MockMediaStreamUI> ui(new MockMediaStreamUI());
 139   EXPECT_CALL(*ui, OnStarted(_));
 140   callback.Run(devices, ui.PassAs<MediaStreamUI>());
 141
 142   MediaStreamDevices response;
 143   EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
 144     .WillOnce(SaveArg<0>(&response));
 145   message_loop_.RunUntilIdle();
 146
 147   EXPECT_FALSE(response.empty());
 148
 149   proxy_->OnStarted(base::Closure());
 150   message_loop_.RunUntilIdle();
 151 }
 152
 153 // Verify that the proxy can be deleted before the request is processed.
 154 TEST_F(MediaStreamUIProxyTest, DeleteBeforeAccepted) {
 155   MediaStreamRequest request(0, 0, 0, std::string(), GURL("http://origin/"),
 156                              MEDIA_GENERATE_STREAM, std::string(),
 157                              std::string(),
 158                              MEDIA_DEVICE_AUDIO_CAPTURE,
 159                              MEDIA_DEVICE_VIDEO_CAPTURE);
 160   proxy_->RequestAccess(
 161       request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
 162                           base::Unretained(&response_callback_)));
 163   MediaResponseCallback callback;
 164   EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
 165     .WillOnce(SaveArg<1>(&callback));
 166   message_loop_.RunUntilIdle();
 167   ASSERT_FALSE(callback.is_null());
 168
 169   proxy_.reset();
 170
 171   MediaStreamDevices devices;
 172   scoped_ptr<MediaStreamUI> ui;
 173   callback.Run(devices, ui.Pass());
 174 }
 175
 176 TEST_F(MediaStreamUIProxyTest, StopFromUI) {
 177   MediaStreamRequest request(0, 0, 0, std::string(), GURL("http://origin/"),
 178                              MEDIA_GENERATE_STREAM, std::string(),
 179                              std::string(),
 180                              MEDIA_DEVICE_AUDIO_CAPTURE,
 181                              MEDIA_DEVICE_VIDEO_CAPTURE);
 182   proxy_->RequestAccess(
 183       request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
 184                           base::Unretained(&response_callback_)));
 185   MediaResponseCallback callback;
 186   EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
 187     .WillOnce(SaveArg<1>(&callback));
 188   message_loop_.RunUntilIdle();
 189   ASSERT_FALSE(callback.is_null());
 190
 191   base::Closure stop_callback;
 192
 193   MediaStreamDevices devices;
 194   devices.push_back(
 195       MediaStreamDevice(MEDIA_DEVICE_AUDIO_CAPTURE, "Mic", "Mic"));
 196   scoped_ptr<MockMediaStreamUI> ui(new MockMediaStreamUI());
 197   EXPECT_CALL(*ui, OnStarted(_))
 198       .WillOnce(SaveArg<0>(&stop_callback));
 199   callback.Run(devices, ui.PassAs<MediaStreamUI>());
 200
 201   MediaStreamDevices response;
 202   EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
 203     .WillOnce(SaveArg<0>(&response));
 204   message_loop_.RunUntilIdle();
 205
 206   EXPECT_FALSE(response.empty());
 207
 208   MockStopStreamHandler stop_handler;
 209   proxy_->OnStarted(base::Bind(&MockStopStreamHandler::OnStop,
 210                                base::Unretained(&stop_handler)));
 211   message_loop_.RunUntilIdle();
 212
 213   ASSERT_FALSE(stop_callback.is_null());
 214   EXPECT_CALL(stop_handler, OnStop());
 215   stop_callback.Run();
 216   message_loop_.RunUntilIdle();
 217 }
 218
 219 }  // content