[Media Router] Custom Controls 2 - add MediaRouter::GetRouteController()

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

Index: chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.cc
diff --git a/chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.cc b/chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.cc
index b4718cc340ec9d56203d597be812c7810e53213c..e00000609cb7483f3111f3832e63fb07bf5793c4 100644
--- a/chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.cc
+++ b/chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.cc
@@ -55,6 +55,7 @@ using testing::Not;
 using testing::Pointee;
 using testing::Return;
 using testing::ReturnRef;
+using testing::Unused;
 using testing::SaveArg;
 using testing::Sequence;
 
@@ -94,6 +95,13 @@ MediaRoute CreateMediaRoute() {
                     std::string(), true);
 }
 
+void OnCreateMediaRouteController(
+    Unused,
+    Unused,
+    const mojom::MediaRouteProvider::CreateMediaRouteControllerCallback& cb) {
+  cb.Run(true);
+}
+
 }  // namespace
 
 class RouteResponseCallbackHandler {
@@ -745,7 +753,6 @@ TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
 
 TEST_F(MediaRouterMojoImplTest,
        RegisterMediaSinksObserverWithAvailabilityChange) {
-
   // When availability is UNAVAILABLE, no calls should be made to MRPM.
   router()->OnSinkAvailabilityUpdated(
       mojom::MediaRouter::SinkAvailability::UNAVAILABLE);
@@ -1182,16 +1189,17 @@ TEST_F(MediaRouterMojoImplTest, SearchSinks) {
   std::string domain("google.com");
   MediaSource media_source(kSource);
 
-  EXPECT_CALL(
-      mock_media_route_provider_, SearchSinks_(kSinkId, kSource, _, _))
-      .WillOnce(Invoke([&search_input, &domain](
-          const std::string& sink_id, const std::string& source,
-          const mojom::SinkSearchCriteriaPtr& search_criteria,
-          const mojom::MediaRouteProvider::SearchSinksCallback& cb) {
-        EXPECT_EQ(search_input, search_criteria->input);
-        EXPECT_EQ(domain, search_criteria->domain);
-        cb.Run(kSinkId2);
-      }));
+  EXPECT_CALL(mock_media_route_provider_,
+              SearchSinksInternal(kSinkId, kSource, _, _))
+      .WillOnce(
+          Invoke([&search_input, &domain](
+                     const std::string& sink_id, const std::string& source,
+                     const mojom::SinkSearchCriteriaPtr& search_criteria,
+                     const mojom::MediaRouteProvider::SearchSinksCallback& cb) {
+            EXPECT_EQ(search_input, search_criteria->input);
+            EXPECT_EQ(domain, search_criteria->domain);
+            cb.Run(kSinkId2);
+          }));
 
   SinkResponseCallbackHandler sink_handler;
   EXPECT_CALL(sink_handler, Invoke(kSinkId2)).Times(1);
@@ -1204,6 +1212,133 @@ TEST_F(MediaRouterMojoImplTest, SearchSinks) {
   run_loop.RunUntilIdle();
 }
 
+TEST_F(MediaRouterMojoImplTest, GetRouteController) {
+  base::RunLoop run_loop1;
+  MockMediaController media_controller;
+  mojom::MediaStatusObserverPtr route_controller_as_observer;
+  MediaStatus media_status;
+  media_status.title = "test title";
+
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateMediaRouteControllerInternal(kRouteId, _, _))
+      .WillOnce(Invoke(
+          [&media_controller](const std::string& route_id,
+                              mojom::MediaControllerRequest& request,
+                              const mojom::MediaRouteProvider::
+                                  CreateMediaRouteControllerCallback& cb) {
+            media_controller.Bind(std::move(request));
+            cb.Run(true);
+          }));
+  EXPECT_CALL(mock_media_route_provider_,
+              SetMediaRouteStatusObserverInternal(kRouteId, _))
+      .WillOnce(Invoke([&route_controller_as_observer](
+                           const std::string& route_id,
+                           mojom::MediaStatusObserverPtr& observer) {
+        route_controller_as_observer = std::move(observer);
+      }));
+  // GetRouteController() should return a MediaRouteController that is connected
+  // to the MediaController provided by the MediaRouteProvider, and will also be
+  // subscribed to MediaStatus updates.
+  scoped_refptr<MediaRouteController> route_controller =
+      router()->GetRouteController(kRouteId);
+
+  // Media commands sent to the MediaRouteController should be forwarded to the
+  // MediaController created by the MediaRouteProvider.
+  EXPECT_CALL(media_controller, Play());
+  route_controller->Play();
+
+  // Add an observer to the MediaRouteController.
+  MockMediaRouteControllerObserver controller_observer(route_controller);
+
+  run_loop1.RunUntilIdle();
+  base::RunLoop run_loop2;
+
+  // The MediaRouteController should be registered with the MediaRouteProvider
+  // as a MediaStatusObserver, and should also notify its own observers.
+  EXPECT_CALL(controller_observer, OnMediaStatusUpdated(media_status));
+  route_controller_as_observer->OnMediaStatusUpdated(media_status);
+
+  run_loop2.RunUntilIdle();
+}
+
+TEST_F(MediaRouterMojoImplTest, GetRouteControllerMultipleTimes) {
+  base::RunLoop run_loop;
+
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateMediaRouteControllerInternal(kRouteId, _, _))
+      .WillOnce(Invoke(OnCreateMediaRouteController));
+  scoped_refptr<MediaRouteController> route_controller1a =
+      router()->GetRouteController(kRouteId);
+
+  // Calling GetRouteController() with the same route ID for the second time
+  // (without destroying the MediaRouteController first) should not result in a
+  // CreateMediaRouteController() call.
+  scoped_refptr<MediaRouteController> route_controller1b =
+      router()->GetRouteController(kRouteId);
+
+  // The same MediaRouteController instance should have been returned.
+  EXPECT_EQ(route_controller1a.get(), route_controller1b.get());
+
+  // Calling GetRouteController() with another route ID should result in a
+  // CreateMediaRouteController() call.
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateMediaRouteControllerInternal(kRouteId2, _, _))
+      .WillOnce(Invoke(OnCreateMediaRouteController));
+  scoped_refptr<MediaRouteController> route_controller2 =
+      router()->GetRouteController(kRouteId2);
+
+  run_loop.RunUntilIdle();
+}
+
+TEST_F(MediaRouterMojoImplTest, GetRouteControllerAfterInvalidation) {
+  base::RunLoop run_loop;
+
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateMediaRouteControllerInternal(kRouteId, _, _))
+      .Times(2)
+      .WillRepeatedly(Invoke(OnCreateMediaRouteController));
+
+  scoped_refptr<MediaRouteController> route_controller =
+      router()->GetRouteController(kRouteId);
+  // Invalidate the MediaRouteController.
+  route_controller = nullptr;
+  // Call again with the same route ID. Since we've invalidated the
+  // MediaRouteController, CreateMediaRouteController() should be called again.
+  route_controller = router()->GetRouteController(kRouteId);
+
+  run_loop.RunUntilIdle();
+}
+
+TEST_F(MediaRouterMojoImplTest, GetRouteControllerAfterRouteInvalidation) {
+  base::RunLoop run_loop;
+
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateMediaRouteControllerInternal(kRouteId, _, _))
+      .WillOnce(Invoke(OnCreateMediaRouteController));
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateMediaRouteControllerInternal(kRouteId2, _, _))
+      .Times(2)
+      .WillRepeatedly(Invoke(OnCreateMediaRouteController));
+
+  MockMediaRouteControllerObserver observer1a(
+      router()->GetRouteController(kRouteId));
+  MockMediaRouteControllerObserver observer2a(
+      router()->GetRouteController(kRouteId2));
+
+  // Update the routes list with |kRouteId| but without |kRouteId2|. This should
+  // remove the controller for |kRouteId2|, resulting in
+  // CreateMediaRouteController() getting called again for |kRouteId2| below.
+  router()->OnRoutesUpdated({CreateMediaRoute()}, std::string(),
+                            std::vector<std::string>());
+
+  MockMediaRouteControllerObserver observer1b(
+      router()->GetRouteController(kRouteId));
+  MockMediaRouteControllerObserver observer2b(
+      router()->GetRouteController(kRouteId2));
+
+  run_loop.RunUntilIdle();
+}

[imcheng, 2017/03/28 01:18:38]

Can you also add a test case where the route controller cannot be created?

[takumif, 2017/03/29 02:34:49]

Done.

+
 class MediaRouterMojoExtensionTest : public ::testing::Test {
  public:
   MediaRouterMojoExtensionTest() : process_manager_(nullptr) {}