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

chrome/browser/ui/webui/media_router/media_router_ui_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 "chrome/browser/ui/webui/media_router/media_router_ui.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #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"
 #include "chrome/common/media_router/media_route.h"
 #include "chrome/common/media_router/media_source_helper.h"
 #include "chrome/common/media_router/route_request_result.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_web_ui.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/test_util.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 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(
       const content::PresentationError& expected_error)
       : expected_error_(expected_error) {}
 
   void Success(const content::PresentationInfo&, const MediaRoute&) {}
 
   void Error(const content::PresentationError& error) {
     EXPECT_EQ(expected_error_.error_type, error.error_type);
@@ skipping 29 matching lines @@
     content::RenderFrameHostTester::CommitPendingLoad(
         &web_contents()->GetController());
     CreateMediaRouterUI(profile);
   }
 
   void CreateMediaRouterUI(Profile* profile) {
     SessionTabHelper::CreateForWebContents(web_contents());
     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);
           return true;
         }));
     EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_))
         .Times(AnyNumber());
     media_router_ui_->InitForTest(&mock_router_, web_contents(),
                                   message_handler_.get(),
                                   std::move(create_session_request_));
     message_handler_->SetWebUIForTest(&web_ui_);
   }
 
   MediaSink CreateSinkCompatibleWithAllSources() {
     MediaSink sink("sinkId", "sinkName", MediaSink::GENERIC);
     for (auto* observer : media_sinks_observers_)
       observer->OnSinksUpdated({sink}, std::vector<url::Origin>());
     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_->OnMediaControllerUIAvailable(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_;
 };
 
 TEST_F(MediaRouterUITest, RouteCreationTimeoutForTab) {
   CreateMediaRouterUI(profile());
   std::vector<MediaRouteResponseCallback> callbacks;
   EXPECT_CALL(
       mock_router_,
       CreateRoute(_, _, _, _, _, base::TimeDelta::FromSeconds(60), false))
       .WillOnce(SaveArg<4>(&callbacks));
@@ skipping 462 matching lines @@
   // Selecting desktop mirroring should not change the recorded preferences.
   EXPECT_FALSE(media_router_ui_->UserSelectedTabMirroringForCurrentOrigin());
 
   media_router_ui_->RecordCastModeSelection(MediaCastMode::TAB_MIRROR);
   EXPECT_TRUE(media_router_ui_->UserSelectedTabMirroringForCurrentOrigin());
   media_router_ui_->RecordCastModeSelection(MediaCastMode::DESKTOP_MIRROR);
   // Selecting desktop mirroring should not change the recorded preferences.
   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_->OnMediaControllerUIClosed();
+
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_router_));
+}
+
+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_));
+}
+
 }  // namespace media_router