Deprecated: [Media Router] Ensure dialog shows route details view if there is one local route

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"
@@ skipping 45 matching lines @@
   content::PresentationError expected_error_;
 };
 
 class MockRoutesUpdatedCallback {
  public:
   MOCK_METHOD2(OnRoutesUpdated,
                void(const std::vector<MediaRoute>& routes,
                     const std::vector<MediaRoute::Id>& joinable_route_ids));
 };
 
+class MockMediaRouterWebUIMessageHandler
+    : public MediaRouterWebUIMessageHandler {
+ public:
+  explicit MockMediaRouterWebUIMessageHandler(MediaRouterUI* media_router_ui)
+      : MediaRouterWebUIMessageHandler(media_router_ui) {}
+  ~MockMediaRouterWebUIMessageHandler() override {}
+
+  MOCK_METHOD3(UpdateRoutes,
+               void(const std::vector<MediaRoute>& routes,
+                    const std::vector<MediaRoute::Id>& joinable_route_ids,
+                    const std::unordered_map<MediaRoute::Id, MediaCastMode>&
+                        current_cast_modes));
+};
+
 class MediaRouterUITest : public ::testing::Test {
  public:
   ~MediaRouterUITest() override {
     EXPECT_CALL(mock_router_, UnregisterMediaSinksObserver(_))
         .Times(AnyNumber());
     EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_))
         .Times(AnyNumber());
   }
 
   void CreateMediaRouterUI(Profile* profile) {
     initiator_.reset(content::WebContents::Create(
         content::WebContents::CreateParams(profile)));
     SessionTabHelper::CreateForWebContents(initiator_.get());
     web_contents_.reset(content::WebContents::Create(
         content::WebContents::CreateParams(profile)));
     web_ui_.set_web_contents(web_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_, initiator_.get(),
                                   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<GURL>());
     return sink;
   }
 
  protected:
   MockMediaRouter mock_router_;
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<content::WebContents> initiator_;
   content::TestWebUI web_ui_;
   std::unique_ptr<content::WebContents> web_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 428 matching lines @@
       MediaSourceForPresentationUrl(presentation_url).id();
   for (auto* observer : media_sinks_observers_) {
     if (observer->source().id() == presentation_source_id) {
       observer->OnSinksUpdated(sinks, origins);
     }
   }
   // Destroying the UI should return the expected error from above to the error
   // callback.
   media_router_ui_.reset();
 }
+
+TEST_F(MediaRouterUITest, UpdateRoutesOnUIInitialized) {
+  std::vector<MediaRoute> routes;
+  std::vector<MediaRoute::Id> joinable_route_ids1;
+  std::vector<MediaRoute::Id> joinable_route_ids2;
+  routes.push_back(MediaRoute("routeId1", MediaSource("sourceId"), "sinkId1",
+                              "desc 1", true, "", true));
+  routes.push_back(MediaRoute("routeId2", MediaSource("sourceId"), "sinkId2",
+                              "desc 2", true, "", false));
+  joinable_route_ids1.push_back("routeId1");
+
+  // If UIInitialized() is called before OnRoutesUpdated() is called for the
+  // first time, then UpdateRoutes() should be called from OnRoutesUpdated().
+  CreateMediaRouterUI(&profile_);
+  EXPECT_CALL(*message_handler_.get(), UpdateRoutes(_, _, _)).Times(0);
+  media_router_ui_->UIInitialized();
+  EXPECT_CALL(*message_handler_.get(),
+              UpdateRoutes(SequenceEquals(routes), joinable_route_ids1, _))
+      .Times(1);
+  media_router_ui_->OnRoutesUpdated(routes, joinable_route_ids1);
+  // Subsequent OnRoutesUpdated() calls should call UpdateRoutes().
+  EXPECT_CALL(*message_handler_.get(),
+              UpdateRoutes(SequenceEquals(routes), joinable_route_ids2, _))
+      .Times(1);
+  media_router_ui_->OnRoutesUpdated(routes, joinable_route_ids2);
+
+  // If UIInitialized() is called after OnRoutesUpdated() is called for the
+  // first time, then UpdateRoutes() should be called from UIInitialized().
+  CreateMediaRouterUI(&profile_);

[mark a. foltz, 2016/11/29 22:24:10]

Nit: Calling this twice in the same test re-uses the same TestWebUI.  Check and
make sure that's a supported use for that object.

+  EXPECT_CALL(*message_handler_.get(), UpdateRoutes(_, _, _)).Times(0);
+  media_router_ui_->OnRoutesUpdated(routes, joinable_route_ids1);
+  EXPECT_CALL(*message_handler_.get(),
+              UpdateRoutes(SequenceEquals(routes), joinable_route_ids1, _))
+      .Times(1);
+  media_router_ui_->UIInitialized();
+  // Subsequent OnRoutesUpdated() calls should call UpdateRoutes().
+  EXPECT_CALL(*message_handler_.get(),
+              UpdateRoutes(SequenceEquals(routes), joinable_route_ids2, _))
+      .Times(1);
+  media_router_ui_->OnRoutesUpdated(routes, joinable_route_ids2);
+}
 }  // namespace media_router