[Media Router] Custom Controls 3 - add plumbing through MRUI and MRWebUIMessageHandler

chrome/browser/ui/webui/media_router/media_router_ui_unittest.cc

Index: chrome/browser/ui/webui/media_router/media_router_ui_unittest.cc
diff --git a/chrome/browser/ui/webui/media_router/media_router_ui_unittest.cc b/chrome/browser/ui/webui/media_router/media_router_ui_unittest.cc
index 716d1a78b68e84e3f9f86f3f921f8a7fd22c0dd6..413291f69863ac900114135f35203016413cd251 100644
--- a/chrome/browser/ui/webui/media_router/media_router_ui_unittest.cc
+++ b/chrome/browser/ui/webui/media_router/media_router_ui_unittest.cc
@@ -11,6 +11,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/media/router/create_presentation_connection_request.h"
 #include "chrome/browser/media/router/mock_media_router.h"
+#include "chrome/browser/media/router/mojo/media_router_mojo_test.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/webui/media_router/media_router_webui_message_handler.h"
@@ -34,11 +35,22 @@ using content::WebContents;
 using testing::_;
 using testing::AnyNumber;
 using testing::Invoke;
+using testing::Mock;
 using testing::Return;
 using testing::SaveArg;
 
 namespace media_router {
 
+class MockMediaRouterWebUIMessageHandler
+    : public MediaRouterWebUIMessageHandler {
+ public:
+  explicit MockMediaRouterWebUIMessageHandler(MediaRouterUI* media_router_ui)
+      : MediaRouterWebUIMessageHandler(media_router_ui) {}
+  ~MockMediaRouterWebUIMessageHandler() override {}
+
+  MOCK_METHOD1(UpdateMediaRouteStatus, void(const MediaStatus& status));
+};
+
 class PresentationRequestCallbacks {
  public:
   explicit PresentationRequestCallbacks(
@@ -88,9 +100,9 @@ class MediaRouterUITest : public ChromeRenderViewHostTestHarness {
     web_ui_contents_.reset(
         WebContents::Create(WebContents::CreateParams(profile)));
     web_ui_.set_web_contents(web_ui_contents_.get());
-    media_router_ui_.reset(new MediaRouterUI(&web_ui_));
-    message_handler_.reset(
-        new MediaRouterWebUIMessageHandler(media_router_ui_.get()));
+    media_router_ui_ = base::MakeUnique<MediaRouterUI>(&web_ui_);
+    message_handler_ = base::MakeUnique<MockMediaRouterWebUIMessageHandler>(
+        media_router_ui_.get());
     EXPECT_CALL(mock_router_, RegisterMediaSinksObserver(_))
         .WillRepeatedly(Invoke([this](MediaSinksObserver* observer) {
           this->media_sinks_observers_.push_back(observer);
@@ -111,13 +123,34 @@ class MediaRouterUITest : public ChromeRenderViewHostTestHarness {
     return sink;
   }
 
+  // Notifies MediaRouterUI that a route details view has been opened. Expects
+  // MediaRouterUI to request a MediaRouteController, and gives it a mock
+  // controller. Returns a reference to the mock controller.
+  scoped_refptr<MockMediaRouteController> OpenUIDetailsView(
+      const MediaRoute::Id& route_id) {
+    MediaSource media_source("mediaSource");
+    MediaRoute route(route_id, media_source, "sinkId", "", true, "", true);
+    mojom::MediaControllerPtr mojo_media_controller;
+    mojo::MakeRequest(&mojo_media_controller);
+    scoped_refptr<MockMediaRouteController> controller =
+        new MockMediaRouteController(route_id, std::move(mojo_media_controller),
+                                     &mock_router_);
+
+    media_router_ui_->OnRoutesUpdated({route}, std::vector<MediaRoute::Id>());
+    EXPECT_CALL(mock_router_, GetRouteController(route_id))
+        .WillOnce(Return(controller));
+    media_router_ui_->OnUIDetailsViewOpened(route_id);
+
+    return controller;
+  }
+
  protected:
   MockMediaRouter mock_router_;
   content::TestWebUI web_ui_;
   std::unique_ptr<WebContents> web_ui_contents_;
   std::unique_ptr<CreatePresentationConnectionRequest> create_session_request_;
   std::unique_ptr<MediaRouterUI> media_router_ui_;
-  std::unique_ptr<MediaRouterWebUIMessageHandler> message_handler_;
+  std::unique_ptr<MockMediaRouterWebUIMessageHandler> message_handler_;
   std::vector<MediaSinksObserver*> media_sinks_observers_;
 };
 
@@ -600,4 +633,97 @@ TEST_F(MediaRouterUITest, RecordDesktopMirroringCastModeSelection) {
   EXPECT_TRUE(media_router_ui_->UserSelectedTabMirroringForCurrentOrigin());
 }
 
+TEST_F(MediaRouterUITest, OpenAndCloseUIDetailsView) {
+  const std::string route_id = "routeId";
+  CreateMediaRouterUI(profile());
+  OpenUIDetailsView(route_id);
+
+  // When the route details view is closed, the route controller observer should
+  // be destroyed, also triggering the destruction of the controller.
+  EXPECT_CALL(mock_router_, DetachRouteController(route_id, _));
+  media_router_ui_->OnUIDetailsViewClosed();
+
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_router_));
+}
+
+TEST_F(MediaRouterUITest, SendMediaCommands) {
+  const base::TimeDelta time = base::TimeDelta::FromSeconds(123);
+  const float volume = 0.7;
+  CreateMediaRouterUI(profile());
+  scoped_refptr<MockMediaRouteController> controller =
+      OpenUIDetailsView("routeId");
+  MediaStatus status;
+  status.duration = base::TimeDelta::FromSeconds(200);
+  controller->OnMediaStatusUpdated(status);
+
+  EXPECT_CALL(*controller, Play());
+  media_router_ui_->PlayRoute();
+  EXPECT_CALL(*controller, Pause());
+  media_router_ui_->PauseRoute();
+  EXPECT_CALL(*controller, Seek(time));
+  media_router_ui_->SeekRoute(time);
+  EXPECT_CALL(*controller, SetMute(true));
+  media_router_ui_->SetRouteMute(true);
+  EXPECT_CALL(*controller, SetVolume(volume));
+  media_router_ui_->SetRouteVolume(volume);
+}
+
+TEST_F(MediaRouterUITest, DoNotSendMediaCommandsForInvalidArgs) {
+  CreateMediaRouterUI(profile());
+  scoped_refptr<MockMediaRouteController> controller =
+      OpenUIDetailsView("routeId");
+  MediaStatus status;
+  status.duration = base::TimeDelta::FromSeconds(100);
+  controller->OnMediaStatusUpdated(status);
+
+  EXPECT_CALL(*controller, Seek(_)).Times(0);
+  EXPECT_CALL(*controller, SetVolume(_)).Times(0);
+
+  // Seek positions greater than the duration or negative should be ignored.

[mark a. foltz, 2017/04/26 21:01:18]

It seems like this is testing behavior of the controller itself (not the UI). 
The test above confirms that commands are relayed to the controller as given.

[takumif, 2017/04/27 03:04:17]

The logic to reject invalid arguments was in MRUI (moved the logic and this test
to the MessageHandler).

+  media_router_ui_->SeekRoute(base::TimeDelta::FromSeconds(101));
+  media_router_ui_->SeekRoute(base::TimeDelta::FromSeconds(-10));
+
+  // Volumes outside of the [0, 1] range should be ignored.
+  media_router_ui_->SetRouteVolume(1.5);
+  media_router_ui_->SetRouteVolume(-0.5);
+}
+
+TEST_F(MediaRouterUITest, SendMediaStatusUpdate) {
+  MediaStatus status;
+  status.title = "test title";
+  CreateMediaRouterUI(profile());
+  scoped_refptr<MockMediaRouteController> controller =
+      OpenUIDetailsView("routeId");
+
+  // The route controller observer held by MediaRouterUI should send the status
+  // update to the message handler.
+  EXPECT_CALL(*message_handler_, UpdateMediaRouteStatus(status));
+  controller->OnMediaStatusUpdated(status);
+
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_router_));
+}
+
+TEST_F(MediaRouterUITest, IsValidRouteId) {
+  const std::string route_id1 = "routeId1";
+  const std::string route_id2 = "routeId2";
+  const std::string route_id3 = "routeId3";
+  MediaSource media_source("mediaSource");
+  MediaRoute route1(route_id1, media_source, "sinkId", "", true, "", true);
+  MediaRoute route2(route_id2, media_source, "sinkId", "", true, "", true);
+  MediaRoute route3(route_id3, media_source, "sinkId", "", true, "", true);
+  CreateMediaRouterUI(profile());
+
+  media_router_ui_->OnRoutesUpdated({route1, route2},
+                                    std::vector<MediaRoute::Id>());
+  EXPECT_TRUE(media_router_ui_->IsValidRouteId(route_id1));
+  EXPECT_TRUE(media_router_ui_->IsValidRouteId(route_id2));
+  EXPECT_FALSE(media_router_ui_->IsValidRouteId(route_id3));
+
+  media_router_ui_->OnRoutesUpdated({route2, route3},
+                                    std::vector<MediaRoute::Id>());
+  EXPECT_FALSE(media_router_ui_->IsValidRouteId(route_id1));
+  EXPECT_TRUE(media_router_ui_->IsValidRouteId(route_id2));
+  EXPECT_TRUE(media_router_ui_->IsValidRouteId(route_id3));
+}
+
 }  // namespace media_router