[Media Router] Custom Controls 1 - Add MediaStatus, MediaRouteController, and mojo interfaces

chrome/browser/media/router/mojo/media_route_controller_unittest.cc

Index: chrome/browser/media/router/mojo/media_route_controller_unittest.cc
diff --git a/chrome/browser/media/router/mojo/media_route_controller_unittest.cc b/chrome/browser/media/router/mojo/media_route_controller_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fcf3e65cd53000f19a97fd8552dc9b9775d9db2f
--- /dev/null
+++ b/chrome/browser/media/router/mojo/media_route_controller_unittest.cc
@@ -0,0 +1,145 @@
+// Copyright 2017 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 "chrome/browser/media/router/mojo/media_route_controller.h"
+
+#include <string>
+#include <utility>
+
+#include "chrome/browser/media/router/media_route_status_observer.h"
+#include "chrome/browser/media/router/mojo/media_router_mojo_test.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::Invoke;
+
+namespace media_router {
+
+class MockMediaController : public mojom::MediaController {

[mark a. foltz, 2017/03/06 20:06:20]

Can these mocks be added to the library in mock_media_router.h?

[takumif, 2017/03/08 04:24:03]

I don't think so, since mock_media_router.h is for Android as well. Or do you
mean media_router_mojo_test.h? Either way, I feel it's alright for these classes
to be here until they're useful elsewhere.

+ public:
+  MOCK_METHOD0(Play, void());
+  MOCK_METHOD0(Pause, void());
+  MOCK_METHOD1(SetMute, void(bool mute));
+  MOCK_METHOD1(SetVolume, void(float volume));
+  MOCK_METHOD1(Seek, void(uint32_t time));
+};
+
+class MockMediaRouteStatusObserver : public MediaRouteStatusObserver {
+ public:
+  MOCK_METHOD1(OnMediaRouteStatusUpdated, void(const MediaStatus& status));
+};
+
+class MediaRouteControllerUnitTest : public ::testing::Test {
+ public:
+  MediaRouteControllerUnitTest() {}
+  ~MediaRouteControllerUnitTest() override {}
+
+  void SetUp() override {
+    mock_provider_ = base::MakeUnique<MockMediaRouteProvider>();
+
+    EXPECT_CALL(*mock_provider_, CreateMediaRouteControllerInternal(_, _, _))
+        .WillOnce(Invoke(
+            this, &MediaRouteControllerUnitTest::SetMediaRouteController));
+    controller_ = base::MakeUnique<MediaRouteController>(
+        "routeId", mock_provider_.get(),
+        base::Bind(&MediaRouteControllerUnitTest::DestroyController,
+                   base::Unretained(this)));
+  }
+
+  void DestroyController() {
+    controller_.reset();
+    OnDestroyController();
+  }
+  MOCK_METHOD0(OnDestroyController, void());
+
+  void SetMediaRouteController(
+      const std::string& route_id,
+      mojom::MediaControllerRequest& media_controller,
+      const mojom::MediaRouteProvider::CreateMediaRouteControllerCallback&
+          callback) {
+    mock_media_controller_ = base::MakeUnique<MockMediaController>();
+    media_controller_binding_ =
+        base::MakeUnique<mojo::Binding<mojom::MediaController>>(
+            mock_media_controller_.get(), std::move(media_controller));
+    callback.Run(true);
+  }
+
+ protected:
+  std::unique_ptr<MediaRouteController> controller_;

[mark a. foltz, 2017/03/06 20:06:20]

Declare members in the order they are initialized.

[takumif, 2017/03/08 04:24:03]

Done.

+  std::unique_ptr<MockMediaRouteProvider> mock_provider_;

[mark a. foltz, 2017/03/06 20:06:19]

Can this just be declared as a plain member?

[takumif, 2017/03/08 04:24:03]

Removed.

+  std::unique_ptr<MockMediaController> mock_media_controller_;
+  std::unique_ptr<mojo::Binding<mojom::MediaController>>
+      media_controller_binding_;
+
+  content::TestBrowserThreadBundle test_thread_bundle_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MediaRouteControllerUnitTest);
+};
+
+TEST_F(MediaRouteControllerUnitTest, ForwardControllerCommands) {
+  const float volume = 0.5;
+  const uint32_t time = 120000;
+
+  EXPECT_CALL(*mock_media_controller_, Play());
+  controller_->Play();
+  EXPECT_CALL(*mock_media_controller_, Pause());
+  controller_->Pause();
+  EXPECT_CALL(*mock_media_controller_, SetMute(true));
+  controller_->SetMute(true);
+  EXPECT_CALL(*mock_media_controller_, SetVolume(volume));
+  controller_->SetVolume(volume);
+  EXPECT_CALL(*mock_media_controller_, Seek(time));
+  controller_->Seek(time);
+}
+
+TEST_F(MediaRouteControllerUnitTest, NotifyMediaRouteStatusObservers) {
+  MockMediaRouteStatusObserver observer1;

[mark a. foltz, 2017/03/06 20:06:19]

Nit: Declare these as StrictMock<> to enforce strict cardinality on the number
of calls (no need for .Times()).

[takumif, 2017/03/08 04:24:03]

Done.

+  MockMediaRouteStatusObserver observer2;
+  MockMediaRouteStatusObserver observer3;
+
+  MediaStatus status;
+  status.title = "test media status";
+
+  controller_->AddObserver(&observer1);
+  controller_->AddObserver(&observer2);
+
+  EXPECT_CALL(observer1, OnMediaRouteStatusUpdated(status)).Times(1);
+  EXPECT_CALL(observer2, OnMediaRouteStatusUpdated(status)).Times(1);
+  EXPECT_CALL(observer3, OnMediaRouteStatusUpdated(status)).Times(0);
+  controller_->OnMediaStatusUpdated(status);
+
+  controller_->RemoveObserver(&observer1);
+  controller_->AddObserver(&observer3);
+
+  EXPECT_CALL(observer1, OnMediaRouteStatusUpdated(status)).Times(0);
+  EXPECT_CALL(observer2, OnMediaRouteStatusUpdated(status)).Times(1);
+  EXPECT_CALL(observer3, OnMediaRouteStatusUpdated(status)).Times(1);
+  controller_->OnMediaStatusUpdated(status);
+}
+
+TEST_F(MediaRouteControllerUnitTest, DestroyControllerOnDisconnect) {
+  // OnDestroyController() should be called when the connection to
+  // |mock_media_controller_| is invalidated.
+  EXPECT_CALL(*this, OnDestroyController()).Times(1);
+  media_controller_binding_.reset();
+}
+
+TEST_F(MediaRouteControllerUnitTest, DestroyControllerOnNoObservers) {
+  MockMediaRouteStatusObserver observer1;
+  MockMediaRouteStatusObserver observer2;
+  controller_->AddObserver(&observer1);
+  controller_->AddObserver(&observer2);
+
+  EXPECT_CALL(*this, OnDestroyController()).Times(0);
+  controller_->RemoveObserver(&observer1);
+
+  // OnDestroyController() should be called when |controller_| no longer has any
+  // observers.
+  EXPECT_CALL(*this, OnDestroyController()).Times(1);
+  controller_->RemoveObserver(&observer2);
+}
+
+}  // namespace media_router