Replace MediaStreamUIController with MediaStreamUIProxy.

content/browser/renderer_host/media/media_stream_ui_proxy_unittest.cc

+// 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.
+
+#include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
+
+#include "base/message_loop.h"
+#include "content/browser/renderer_host/render_view_host_delegate.h"
+#include "content/public/common/renderer_preferences.h"
+#include "content/public/test/test_browser_thread.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/rect.h"
+
+using testing::_;
+using testing::SaveArg;
+
+namespace content {
+namespace {
+
+class MockRenderViewHostDelegate : public RenderViewHostDelegate {
+ public:
+  MOCK_METHOD2(RequestMediaAccessPermission,
+               void(const MediaStreamRequest& request,
+                    const MediaResponseCallback& callback));
+
+  // Stubs for pure virtual methods we don't care about.
+  virtual gfx::Rect GetRootWindowResizerRect() const OVERRIDE {
+    NOTREACHED();
+    return gfx::Rect();
+  }
+  virtual RendererPreferences GetRendererPrefs(
+      BrowserContext* browser_context) const OVERRIDE {
+    NOTREACHED();
+    return RendererPreferences();
+  }
+};
+
+class MockResponseCallback {
+ public:
+  MOCK_METHOD1(OnAccessRequestResponse,
+               void(const MediaStreamDevices& devices));
+};
+
+class MockMediaStreamUI : public MediaStreamUI {
+ public:
+  MOCK_METHOD1(OnStarted, void(const base::Closure& stop));
+};
+
+class MockStopStreamHandler {
+ public:
+  MOCK_METHOD0(OnStop, void());
+};
+
+
+}  // namespace
+
+class MediaStreamUIProxyTest : public testing::Test {
+ public:
+  MediaStreamUIProxyTest()
+      : ui_thread_(BrowserThread::UI, &message_loop_),
+        io_thread_(BrowserThread::IO, &message_loop_) {
+    proxy_.reset(new MediaStreamUIProxy());

[miu, 2013/06/06 20:03:01]

Yeah, just use injection (suggested in other comment):

  proxy_.reset(new MediaStreamUIProxy(&delegate_));

[Sergey Ulanov, 2013/06/06 21:40:03]

Done.

+    proxy_->SetRenderViewHostDelegateForTests(&delegate_);
+  }
+
+  ~MediaStreamUIProxyTest() {
+    proxy_.reset();
+    message_loop_.RunUntilIdle();
+  }
+
+ protected:
+  base::MessageLoop message_loop_;
+  TestBrowserThread ui_thread_;
+  TestBrowserThread io_thread_;
+
+  MockRenderViewHostDelegate delegate_;
+  MockResponseCallback response_callback_;
+  scoped_ptr<MediaStreamUIProxy> proxy_;
+};
+
+MATCHER_P(SameRequest, expected, "") {
+  return

[miu, 2013/06/06 20:03:01]

Can this just be:

  return expected == arg;

Since MediaStreamRequest is a struct, C++ should generate a default operator==()
for you.  The risk in doing it yourself is that this code could become
out-of-sync with that in media_stream_request.h.

[Sergey Ulanov, 2013/06/06 21:40:03]

Nope, there is no implicit comparison operator for structs, I would have to
declare it explicitly (e.g. see
http://stackoverflow.com/questions/5740310/no-operator-found-while-comparing-...)

[miu, 2013/06/06 23:05:23]

Ah, my mistake.  Not sure why I keep thinking C++ provides it.  Maybe because it
provides operator=() and a copy ctor by default...

I'll leave it up to you, but it would probably be safer to implement this code
as an operator==() method in the MediaStreamRequest struct in
media_stream_request.h.  Someone down the line might change the struct without
changing your code here.

[Sergey Ulanov, 2013/06/07 00:37:09]

I'd rather leave it as is - code style discourages operator overloading. I could
add Equals() method, but this unittest would be the only place that needs it,
and it isn't crucial for it to compare all members.

+    expected.render_process_id == arg.render_process_id &&
+    expected.render_view_id == arg.render_view_id &&
+    expected.security_origin == arg.security_origin &&
+    expected.request_type == arg.request_type &&
+    expected.requested_device_id == arg.requested_device_id &&
+    expected.audio_type == arg.audio_type &&
+    expected.video_type == arg.video_type;
+}
+
+TEST_F(MediaStreamUIProxyTest, Deny) {
+  MediaStreamRequest request(0, 0, GURL("http://origin/"),
+                             MEDIA_GENERATE_STREAM, std::string(),
+                             MEDIA_DEVICE_AUDIO_CAPTURE,
+                             MEDIA_DEVICE_VIDEO_CAPTURE);
+  proxy_->RequestAccess(
+      request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
+                          base::Unretained(&response_callback_)));
+  MediaResponseCallback callback;
+  EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
+    .WillOnce(SaveArg<1>(&callback));
+  message_loop_.RunUntilIdle();
+  ASSERT_FALSE(callback.is_null());
+
+  MediaStreamDevices devices;
+  callback.Run(devices, scoped_ptr<MediaStreamUI>());
+
+  MediaStreamDevices response;
+  EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
+    .WillOnce(SaveArg<0>(&response));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_TRUE(response.empty());
+}
+
+TEST_F(MediaStreamUIProxyTest, AcceptAndStart) {
+  MediaStreamRequest request(0, 0, GURL("http://origin/"),
+                             MEDIA_GENERATE_STREAM, std::string(),
+                             MEDIA_DEVICE_AUDIO_CAPTURE,
+                             MEDIA_DEVICE_VIDEO_CAPTURE);
+  proxy_->RequestAccess(
+      request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
+                          base::Unretained(&response_callback_)));
+  MediaResponseCallback callback;
+  EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
+    .WillOnce(SaveArg<1>(&callback));
+  message_loop_.RunUntilIdle();
+  ASSERT_FALSE(callback.is_null());
+
+  MediaStreamDevices devices;
+  devices.push_back(
+      MediaStreamDevice(MEDIA_DEVICE_AUDIO_CAPTURE, "Mic", "Mic"));
+  scoped_ptr<MockMediaStreamUI> ui(new MockMediaStreamUI());
+  EXPECT_CALL(*ui, OnStarted(_));
+  callback.Run(devices, ui.PassAs<MediaStreamUI>());
+
+  MediaStreamDevices response;
+  EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
+    .WillOnce(SaveArg<0>(&response));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_FALSE(response.empty());
+
+  proxy_->OnStarted(base::Closure());
+  message_loop_.RunUntilIdle();
+}
+
+// Verify that the proxy can be deleted before the request is processed.
+TEST_F(MediaStreamUIProxyTest, DeleteBeforeAccepted) {
+  MediaStreamRequest request(0, 0, GURL("http://origin/"),
+                             MEDIA_GENERATE_STREAM, std::string(),
+                             MEDIA_DEVICE_AUDIO_CAPTURE,
+                             MEDIA_DEVICE_VIDEO_CAPTURE);
+  proxy_->RequestAccess(
+      request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
+                          base::Unretained(&response_callback_)));
+  MediaResponseCallback callback;
+  EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
+    .WillOnce(SaveArg<1>(&callback));
+  message_loop_.RunUntilIdle();
+  ASSERT_FALSE(callback.is_null());
+
+  proxy_.reset();
+
+  MediaStreamDevices devices;
+  scoped_ptr<MediaStreamUI> ui;
+  callback.Run(devices, ui.Pass());
+}
+
+TEST_F(MediaStreamUIProxyTest, StopFromUI) {
+  MediaStreamRequest request(0, 0, GURL("http://origin/"),
+                             MEDIA_GENERATE_STREAM, std::string(),
+                             MEDIA_DEVICE_AUDIO_CAPTURE,
+                             MEDIA_DEVICE_VIDEO_CAPTURE);
+  proxy_->RequestAccess(
+      request, base::Bind(&MockResponseCallback::OnAccessRequestResponse,
+                          base::Unretained(&response_callback_)));
+  MediaResponseCallback callback;
+  EXPECT_CALL(delegate_, RequestMediaAccessPermission(SameRequest(request), _))
+    .WillOnce(SaveArg<1>(&callback));
+  message_loop_.RunUntilIdle();
+  ASSERT_FALSE(callback.is_null());
+
+  base::Closure stop_callback;
+
+  MediaStreamDevices devices;
+  devices.push_back(
+      MediaStreamDevice(MEDIA_DEVICE_AUDIO_CAPTURE, "Mic", "Mic"));
+  scoped_ptr<MockMediaStreamUI> ui(new MockMediaStreamUI());
+  EXPECT_CALL(*ui, OnStarted(_))
+      .WillOnce(SaveArg<0>(&stop_callback));
+  callback.Run(devices, ui.PassAs<MediaStreamUI>());
+
+  MediaStreamDevices response;
+  EXPECT_CALL(response_callback_, OnAccessRequestResponse(_))
+    .WillOnce(SaveArg<0>(&response));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_FALSE(response.empty());
+
+  MockStopStreamHandler stop_handler;
+  proxy_->OnStarted(base::Bind(&MockStopStreamHandler::OnStop,
+                               base::Unretained(&stop_handler)));
+  message_loop_.RunUntilIdle();
+
+  ASSERT_FALSE(stop_callback.is_null());
+  EXPECT_CALL(stop_handler, OnStop());
+  stop_callback.Run();
+  message_loop_.RunUntilIdle();
+}
+
+}  // content