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

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

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"

[imcheng, 2017/04/07 22:45:48]

#include not needed?

[takumif, 2017/04/11 04:08:37]

Removed.

 #include "base/test/histogram_tester.h"
 #include "base/test/mock_callback.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_test.h"
 #include "chrome/browser/media/router/route_message.h"
@@ skipping 19 matching lines @@
 using testing::AtMost;
 using testing::Eq;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::IsEmpty;
 using testing::Mock;
 using testing::Not;
 using testing::Pointee;
 using testing::Return;
 using testing::ReturnRef;
+using testing::Unused;
 using testing::SaveArg;
 using testing::Sequence;
 
 namespace media_router {
 
 namespace {
 
 const char kDescription[] = "description";
 const char kError[] = "error";
 const char kMessage[] = "message";
@@ skipping 14 matching lines @@
 
 IssueInfo CreateIssueInfo(const std::string& title) {
   IssueInfo issue_info;
   issue_info.title = title;
   issue_info.message = std::string("msg");
   issue_info.default_action = IssueInfo::Action::DISMISS;
   issue_info.severity = IssueInfo::Severity::WARNING;
   return issue_info;
 }
 
+// Creates a media route whose ID is |kRouteId|.
 MediaRoute CreateMediaRoute() {
   return MediaRoute(kRouteId, MediaSource(kSource), kSinkId, kDescription, true,
                     std::string(), true);
 }
 
+// Creates a media route whose ID is |kRouteId2|.
+MediaRoute CreateMediaRoute2() {
+  return MediaRoute(kRouteId2, MediaSource(kSource), kSinkId, kDescription,
+                    true, std::string(), true);
+}
+
+void OnCreateMediaRouteController(
+    Unused,
+    Unused,
+    const mojom::MediaRouteProvider::CreateMediaRouteControllerCallback& cb) {
+  cb.Run(true);
+}
+
 }  // namespace
 
 class RouteResponseCallbackHandler {
  public:
   void Invoke(const RouteRequestResult& result) {
     DoInvoke(result.route(), result.presentation_id(), result.error(),
              result.result_code());
   }
   MOCK_METHOD4(DoInvoke,
                void(const MediaRoute* route,
@@ skipping 631 matching lines @@
   sinks_observer.reset();
   extra_sinks_observer.reset();
   unrelated_sinks_observer.reset();
   cached_sinks_observer.reset();
   cached_sinks_observer2.reset();
   run_loop2.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest,
        RegisterMediaSinksObserverWithAvailabilityChange) {
-
   // When availability is UNAVAILABLE, no calls should be made to MRPM.
   router()->OnSinkAvailabilityUpdated(
       mojom::MediaRouter::SinkAvailability::UNAVAILABLE);
   MediaSource media_source(kSource);
   std::unique_ptr<MockMediaSinksObserver> sinks_observer(
       new MockMediaSinksObserver(router(), media_source,
                                  url::Origin(GURL(kOrigin))));
   EXPECT_CALL(*sinks_observer, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(sinks_observer->Init());
   MediaSource media_source2(kSource2);
@@ skipping 416 matching lines @@
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId2));
   ConnectProviderManagerService();
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, SearchSinks) {
   std::string search_input("input");
   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);
   MediaSinkSearchResponseCallback sink_callback = base::Bind(
       &SinkResponseCallbackHandler::Invoke, base::Unretained(&sink_handler));
 
   router()->SearchSinks(kSinkId, kSource, search_input, domain, sink_callback);
 
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
@@ skipping 11 matching lines @@
   std::string provider_name = "cast";
 
   EXPECT_CALL(mock_media_route_provider_, ProvideSinks(provider_name, sinks));
 
   router()->ProvideSinks(provider_name, sinks);
 
   base::RunLoop run_loop;
   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";
+
+  router()->OnRoutesUpdated({CreateMediaRoute()}, std::string(),
+                            std::vector<std::string>());
+
+  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);
+  run_loop1.RunUntilIdle();
+
+  // 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);
+
+  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;
+  router()->OnRoutesUpdated({CreateMediaRoute(), CreateMediaRoute2()},
+                            std::string(), std::vector<std::string>());
+
+  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;
+  router()->OnRoutesUpdated({CreateMediaRoute()}, std::string(),
+                            std::vector<std::string>());
+
+  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;
+  router()->OnRoutesUpdated({CreateMediaRoute(), CreateMediaRoute2()},
+                            std::string(), std::vector<std::string>());
+
+  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>());
+  // Add back |kRouteId2| so that a controller can be created for it.
+  router()->OnRoutesUpdated({CreateMediaRoute(), CreateMediaRoute2()},
+                            std::string(), std::vector<std::string>());
+
+  MockMediaRouteControllerObserver observer1b(
+      router()->GetRouteController(kRouteId));
+  MockMediaRouteControllerObserver observer2b(
+      router()->GetRouteController(kRouteId2));
+
+  run_loop.RunUntilIdle();
+}
+
+TEST_F(MediaRouterMojoImplTest, FailToCreateRouteController) {
+  base::RunLoop run_loop;
+  router()->OnRoutesUpdated({CreateMediaRoute()}, std::string(),
+                            std::vector<std::string>());
+
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateMediaRouteControllerInternal(kRouteId, _, _))
+      .WillOnce(Invoke(
+          [](Unused, Unused,
+             const mojom::MediaRouteProvider::
+                 CreateMediaRouteControllerCallback& cb) { cb.Run(false); }));
+  MockMediaRouteControllerObserver observer(
+      router()->GetRouteController(kRouteId));
+
+  // When the MediaRouter is notified that the MediaRouteProvider failed to
+  // create a controller, the browser-side controller should be invalidated.
+  EXPECT_CALL(observer, OnControllerInvalidated());
+
+  run_loop.RunUntilIdle();
+}
+
 class MediaRouterMojoExtensionTest : public ::testing::Test {
  public:
   MediaRouterMojoExtensionTest() : process_manager_(nullptr) {}
 
   ~MediaRouterMojoExtensionTest() override {}
 
  protected:
   void SetUp() override {
     // Set the extension's version number to be identical to the browser's.
     extension_ =
@@ skipping 360 matching lines @@
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
 }  // namespace media_router