Add GetCurrentRoutes() to MediaRouter API, ensure dialog has routes at init

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 47 matching lines @@
 
 class MockRoutesUpdatedCallback {
  public:
   MOCK_METHOD2(OnRoutesUpdated,
                void(const std::vector<MediaRoute>& routes,
                     const std::vector<MediaRoute::Id>& joinable_route_ids));
 };
 
 class MediaRouterUITest : public ChromeRenderViewHostTestHarness {
  public:
+  MediaRouterUITest() {
+    ON_CALL(mock_router_, GetCurrentRoutes())
+        .WillByDefault(Return(std::vector<MediaRoute>()));
+  }
+
   void TearDown() override {
     EXPECT_CALL(mock_router_, UnregisterMediaSinksObserver(_))
         .Times(AnyNumber());
     EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_))
         .Times(AnyNumber());
     web_ui_contents_.reset();
     create_session_request_.reset();
     media_router_ui_.reset();
     message_handler_.reset();
     ChromeRenderViewHostTestHarness::TearDown();
@@ skipping 194 matching lines @@
   media_router_ui_->OnResultsUpdated(unsorted_sinks);
   const auto& sorted_sinks = media_router_ui_->sinks_;
   EXPECT_EQ(sink6.sink.id(), sorted_sinks[0].sink.id());
   EXPECT_EQ(sink4.sink.id(), sorted_sinks[1].sink.id());
   EXPECT_EQ(sink2.sink.id(), sorted_sinks[2].sink.id());
   EXPECT_EQ(sink5.sink.id(), sorted_sinks[3].sink.id());
   EXPECT_EQ(sink1.sink.id(), sorted_sinks[4].sink.id());
   EXPECT_EQ(sink3.sink.id(), sorted_sinks[5].sink.id());
 }
 
-TEST_F(MediaRouterUITest, UIMediaRoutesObserverFiltersNonDisplayRoutes) {
-  EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_)).Times(1);
+TEST_F(MediaRouterUITest, FilterNonDisplayRoutes) {
+  CreateMediaRouterUI(profile());
+
   MediaSource media_source("mediaSource");
-  MockRoutesUpdatedCallback mock_callback;
-  std::unique_ptr<MediaRouterUI::UIMediaRoutesObserver> observer(
-      new MediaRouterUI::UIMediaRoutesObserver(
-          &mock_router_, media_source.id(),
-          base::Bind(&MockRoutesUpdatedCallback::OnRoutesUpdated,
-                     base::Unretained(&mock_callback))));
-
   MediaRoute display_route_1("routeId1", media_source, "sinkId1", "desc 1",
                              true, "", true);
   MediaRoute non_display_route_1("routeId2", media_source, "sinkId2", "desc 2",
                                  true, "", false);
   MediaRoute display_route_2("routeId3", media_source, "sinkId2", "desc 2",
                              true, "", true);
   std::vector<MediaRoute> routes;
   routes.push_back(display_route_1);
   routes.push_back(non_display_route_1);
   routes.push_back(display_route_2);
 
-  std::vector<MediaRoute> filtered_routes;
-  EXPECT_CALL(mock_callback, OnRoutesUpdated(_, _))
-      .WillOnce(SaveArg<0>(&filtered_routes));
-  observer->OnRoutesUpdated(routes, std::vector<MediaRoute::Id>());
-
-  ASSERT_EQ(2u, filtered_routes.size());
-  EXPECT_TRUE(display_route_1.Equals(filtered_routes[0]));
-  EXPECT_TRUE(filtered_routes[0].for_display());
-  EXPECT_TRUE(display_route_2.Equals(filtered_routes[1]));
-  EXPECT_TRUE(filtered_routes[1].for_display());
-
-  EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_)).Times(1);
-  observer.reset();
+  media_router_ui_->OnRoutesUpdated(routes, std::vector<MediaRoute::Id>());
+  ASSERT_EQ(2u, media_router_ui_->routes_.size());
+  EXPECT_TRUE(display_route_1.Equals(media_router_ui_->routes_[0]));
+  EXPECT_TRUE(media_router_ui_->routes_[0].for_display());
+  EXPECT_TRUE(display_route_2.Equals(media_router_ui_->routes_[1]));
+  EXPECT_TRUE(media_router_ui_->routes_[1].for_display());
 }
 
-TEST_F(MediaRouterUITest,
-    UIMediaRoutesObserverFiltersNonDisplayJoinableRoutes) {
-  EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_)).Times(1);
+TEST_F(MediaRouterUITest, FilterNonDisplayJoinableRoutes) {
+  CreateMediaRouterUI(profile());
+
   MediaSource media_source("mediaSource");
-  MockRoutesUpdatedCallback mock_callback;
-  std::unique_ptr<MediaRouterUI::UIMediaRoutesObserver> observer(
-      new MediaRouterUI::UIMediaRoutesObserver(
-          &mock_router_, media_source.id(),
-          base::Bind(&MockRoutesUpdatedCallback::OnRoutesUpdated,
-                     base::Unretained(&mock_callback))));
-
   MediaRoute display_route_1("routeId1", media_source, "sinkId1", "desc 1",
                              true, "", true);
   MediaRoute non_display_route_1("routeId2", media_source, "sinkId2", "desc 2",
                                  true, "", false);
   MediaRoute display_route_2("routeId3", media_source, "sinkId2", "desc 2",
                              true, "", true);
   std::vector<MediaRoute> routes;
   routes.push_back(display_route_1);
   routes.push_back(non_display_route_1);
   routes.push_back(display_route_2);
 
   std::vector<MediaRoute::Id> joinable_route_ids;
   joinable_route_ids.push_back("routeId1");
   joinable_route_ids.push_back("routeId2");
   joinable_route_ids.push_back("routeId3");
 
-  std::vector<MediaRoute::Id> filtered_joinable_route_ids;
-  // Save the filtered joinable routes.
-  EXPECT_CALL(mock_callback, OnRoutesUpdated(_, _))
-      .WillOnce(SaveArg<1>(&filtered_joinable_route_ids));
-  observer->OnRoutesUpdated(routes, joinable_route_ids);
-
-  ASSERT_EQ(2u, filtered_joinable_route_ids.size());
-  EXPECT_EQ(display_route_1.media_route_id(), filtered_joinable_route_ids[0]);
-  EXPECT_EQ(display_route_2.media_route_id(), filtered_joinable_route_ids[1]);
-
-  EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_)).Times(1);
-  observer.reset();
+  media_router_ui_->OnRoutesUpdated(routes, joinable_route_ids);
+  ASSERT_EQ(2u, media_router_ui_->joinable_route_ids_.size());
+  EXPECT_EQ(display_route_1.media_route_id(),
+            media_router_ui_->joinable_route_ids_[0]);
+  EXPECT_EQ(display_route_2.media_route_id(),
+            media_router_ui_->joinable_route_ids_[1]);
 }
 
 TEST_F(MediaRouterUITest, UIMediaRoutesObserverAssignsCurrentCastModes) {
   CreateMediaRouterUI(profile());
   SessionID::id_type tab_id = SessionTabHelper::IdForTab(web_contents());
   MediaSource media_source_1(MediaSourceForTab(tab_id));
   MediaSource media_source_2("mediaSource");
   MediaSource media_source_3(MediaSourceForDesktop());
   MockRoutesUpdatedCallback mock_callback;
   std::unique_ptr<MediaRouterUI::UIMediaRoutesObserver> observer(
@@ skipping 15 matching lines @@
 
   observer->OnRoutesUpdated(routes, std::vector<MediaRoute::Id>());
 
   const auto& filtered_routes = media_router_ui_->routes();
   ASSERT_EQ(2u, filtered_routes.size());
   EXPECT_TRUE(display_route_1.Equals(filtered_routes[0]));
   EXPECT_TRUE(filtered_routes[0].for_display());
   EXPECT_TRUE(display_route_2.Equals(filtered_routes[1]));
   EXPECT_TRUE(filtered_routes[1].for_display());
 
-  const auto& current_cast_modes = media_router_ui_->current_cast_modes();
+  const auto& current_cast_modes = media_router_ui_->routes_and_cast_modes();
   ASSERT_EQ(2u, current_cast_modes.size());
   auto cast_mode_entry =
       current_cast_modes.find(display_route_1.media_route_id());
   EXPECT_NE(end(current_cast_modes), cast_mode_entry);
   EXPECT_EQ(MediaCastMode::TAB_MIRROR, cast_mode_entry->second);
   cast_mode_entry =
       current_cast_modes.find(non_display_route_1.media_route_id());
   EXPECT_EQ(end(current_cast_modes), cast_mode_entry);
   cast_mode_entry = current_cast_modes.find(display_route_2.media_route_id());
   EXPECT_NE(end(current_cast_modes), cast_mode_entry);
@@ skipping 28 matching lines @@
 
   observer->OnRoutesUpdated(routes, std::vector<MediaRoute::Id>());
 
   const auto& filtered_routes = media_router_ui_->routes();
   ASSERT_EQ(2u, filtered_routes.size());
   EXPECT_TRUE(display_route_1.Equals(filtered_routes[0]));
   EXPECT_TRUE(filtered_routes[0].for_display());
   EXPECT_TRUE(display_route_2.Equals(filtered_routes[1]));
   EXPECT_TRUE(filtered_routes[1].for_display());
 
-  const auto& current_cast_modes = media_router_ui_->current_cast_modes();
+  const auto& current_cast_modes = media_router_ui_->routes_and_cast_modes();
   ASSERT_EQ(1u, current_cast_modes.size());
   auto cast_mode_entry =
       current_cast_modes.find(display_route_1.media_route_id());
   // No observer for source "mediaSource1" means no cast mode for this route.
   EXPECT_EQ(end(current_cast_modes), cast_mode_entry);
   cast_mode_entry =
       current_cast_modes.find(non_display_route_1.media_route_id());
   EXPECT_EQ(end(current_cast_modes), cast_mode_entry);
   cast_mode_entry = current_cast_modes.find(display_route_2.media_route_id());
   EXPECT_NE(end(current_cast_modes), cast_mode_entry);
@@ skipping 154 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());
 }
 }  // namespace media_router