[Media Router] Assign each route a current cast mode if possible

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 "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/media/router/media_route.h"
@@ skipping 10 matching lines @@
 #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 testing::_;
 using testing::AnyNumber;
+using testing::DoAll;
 using testing::SaveArg;
 using testing::Return;
 
 namespace media_router {
 
 class MockRoutesUpdatedCallback {
  public:
-  MOCK_METHOD2(OnRoutesUpdated,
+  MOCK_METHOD0(GetAvailableSourceMap,
+               std::unordered_map<MediaSource::Id, MediaCastMode>());
+  MOCK_METHOD3(OnRoutesUpdated,
                void(const std::vector<MediaRoute>& routes,
-                    const std::vector<MediaRoute::Id>& joinable_route_ids));
+                    const std::vector<MediaRoute::Id>& joinable_route_ids,
+                    const std::unordered_map<MediaRoute::Id, MediaCastMode>&
+                        current_cast_mode));
 };
 
 class MediaRouterUITest : public ::testing::Test {
  public:
   ~MediaRouterUITest() override {
     EXPECT_CALL(mock_router_, UnregisterMediaSinksObserver(_))
         .Times(AnyNumber());
     EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_))
         .Times(AnyNumber());
   }
@@ skipping 144 matching lines @@
   EXPECT_EQ(sink_id1, sorted_sinks[2].sink.id());
 }
 
 TEST_F(MediaRouterUITest, UIMediaRoutesObserverFiltersNonDisplayRoutes) {
   EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_)).Times(1);
   MediaSource media_source("mediaSource");
   MockRoutesUpdatedCallback mock_callback;
   std::unique_ptr<MediaRouterUI::UIMediaRoutesObserver> observer(
       new MediaRouterUI::UIMediaRoutesObserver(
           &mock_router_, media_source.id(),
+          base::Bind(&MockRoutesUpdatedCallback::GetAvailableSourceMap,
+                     base::Unretained(&mock_callback)),
           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));
+  std::unordered_map<MediaSource::Id, MediaCastMode> available_source_map;
+  available_source_map.insert(
+      std::make_pair(media_source.id(), MediaCastMode::DEFAULT));
+  std::unordered_map<MediaRoute::Id, MediaCastMode> current_cast_modes;
+  ON_CALL(mock_callback, GetAvailableSourceMap())
+      .WillByDefault(Return(available_source_map));
+  EXPECT_CALL(mock_callback, OnRoutesUpdated(_, _, _)).WillOnce(
+      DoAll(SaveArg<0>(&filtered_routes), SaveArg<2>(&current_cast_modes)));
   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());
 
+  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::DEFAULT, 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);
+  EXPECT_EQ(MediaCastMode::DEFAULT, cast_mode_entry->second);
+
   EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_)).Times(1);
   observer.reset();
 }
 
 TEST_F(MediaRouterUITest,
     UIMediaRoutesObserverFiltersNonDisplayJoinableRoutes) {
   EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_)).Times(1);
   MediaSource media_source("mediaSource");
   MockRoutesUpdatedCallback mock_callback;
   std::unique_ptr<MediaRouterUI::UIMediaRoutesObserver> observer(
       new MediaRouterUI::UIMediaRoutesObserver(
           &mock_router_, media_source.id(),
+          base::Bind(&MockRoutesUpdatedCallback::GetAvailableSourceMap,
+                     base::Unretained(&mock_callback)),
           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;
+  std::unordered_map<MediaSource::Id, MediaCastMode> available_source_map;
+  available_source_map.insert(
+      std::make_pair(media_source.id(), MediaCastMode::DEFAULT));
+  std::unordered_map<MediaRoute::Id, MediaCastMode> current_cast_modes;
+  ON_CALL(mock_callback, GetAvailableSourceMap())
+      .WillByDefault(Return(available_source_map));
   // Save the filtered joinable routes.
-  EXPECT_CALL(mock_callback, OnRoutesUpdated(_, _)).WillOnce(
-      SaveArg<1>(&filtered_joinable_route_ids));
+  EXPECT_CALL(mock_callback, OnRoutesUpdated(_, _, _)).WillOnce(
+      DoAll(SaveArg<1>(&filtered_joinable_route_ids),
+            SaveArg<2>(&current_cast_modes)));
   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]);
 
+  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::DEFAULT, 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);
+  EXPECT_EQ(MediaCastMode::DEFAULT, cast_mode_entry->second);
+
   EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_)).Times(1);
   observer.reset();
 }
+
+TEST_F(MediaRouterUITest, UIMediaRoutesObserverAssignsCurrentCastModes) {
+  EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_)).Times(1);
+  MediaSource media_source_1("mediaSource1");
+  MediaSource media_source_2("mediaSource2");
+  MediaSource media_source_3("mediaSource3");
+  MockRoutesUpdatedCallback mock_callback;
+  std::unique_ptr<MediaRouterUI::UIMediaRoutesObserver> observer(
+      new MediaRouterUI::UIMediaRoutesObserver(
+          &mock_router_, MediaSource::Id(),
+          base::Bind(&MockRoutesUpdatedCallback::GetAvailableSourceMap,
+                     base::Unretained(&mock_callback)),
+          base::Bind(&MockRoutesUpdatedCallback::OnRoutesUpdated,
+                     base::Unretained(&mock_callback))));
+
+  MediaRoute display_route_1("routeId1", media_source_1, "sinkId1", "desc 1",
+                             true, "", true);
+  MediaRoute non_display_route_1("routeId2", media_source_2, "sinkId2",
+                                 "desc 2", true, "", false);
+  MediaRoute display_route_2("routeId3", media_source_3, "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;
+  std::unordered_map<MediaSource::Id, MediaCastMode> available_source_map;
+  available_source_map.insert(std::make_pair(
+      display_route_1.media_source().id(), MediaCastMode::DEFAULT));
+  available_source_map.insert(std::make_pair(
+      non_display_route_1.media_source().id(), MediaCastMode::TAB_MIRROR));
+  available_source_map.insert(std::make_pair(
+      display_route_2.media_source().id(), MediaCastMode::DESKTOP_MIRROR));
+  std::unordered_map<MediaRoute::Id, MediaCastMode> current_cast_modes;
+  ON_CALL(mock_callback, GetAvailableSourceMap())
+      .WillByDefault(Return(available_source_map));
+  EXPECT_CALL(mock_callback, OnRoutesUpdated(_, _, _)).WillOnce(
+      DoAll(SaveArg<0>(&filtered_routes), SaveArg<2>(&current_cast_modes)));
+  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());
+
+  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::DEFAULT, 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);
+  EXPECT_EQ(MediaCastMode::DESKTOP_MIRROR, cast_mode_entry->second);
+
+  EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_)).Times(1);
+  observer.reset();
+}
+
+TEST_F(MediaRouterUITest, UIMediaRoutesObserverSkipsUnavailableCastModes) {
+  EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_)).Times(1);
+  MediaSource media_source_1("mediaSource1");
+  MediaSource media_source_2("mediaSource2");
+  MediaSource media_source_3("mediaSource3");
+  MockRoutesUpdatedCallback mock_callback;
+  std::unique_ptr<MediaRouterUI::UIMediaRoutesObserver> observer(
+      new MediaRouterUI::UIMediaRoutesObserver(
+          &mock_router_, MediaSource::Id(),
+          base::Bind(&MockRoutesUpdatedCallback::GetAvailableSourceMap,
+                     base::Unretained(&mock_callback)),
+          base::Bind(&MockRoutesUpdatedCallback::OnRoutesUpdated,
+                     base::Unretained(&mock_callback))));
+
+  MediaRoute display_route_1("routeId1", media_source_1, "sinkId1", "desc 1",
+                             true, "", true);
+  MediaRoute non_display_route_1("routeId2", media_source_2, "sinkId2",
+                                 "desc 2", true, "", false);
+  MediaRoute display_route_2("routeId3", media_source_3, "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;
+  std::unordered_map<MediaSource::Id, MediaCastMode> available_source_map;
+  available_source_map.insert(std::make_pair(
+      non_display_route_1.media_source().id(), MediaCastMode::TAB_MIRROR));
+  available_source_map.insert(std::make_pair(
+      display_route_2.media_source().id(), MediaCastMode::DESKTOP_MIRROR));
+  std::unordered_map<MediaRoute::Id, MediaCastMode> current_cast_modes;
+  ON_CALL(mock_callback, GetAvailableSourceMap())
+      .WillByDefault(Return(available_source_map));
+  EXPECT_CALL(mock_callback, OnRoutesUpdated(_, _, _)).WillOnce(
+      DoAll(SaveArg<0>(&filtered_routes), SaveArg<2>(&current_cast_modes)));
+  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());
+
+  ASSERT_EQ(1u, current_cast_modes.size());
+  auto cast_mode_entry =
+      current_cast_modes.find(display_route_1.media_route_id());
+  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);
+  EXPECT_EQ(MediaCastMode::DESKTOP_MIRROR, cast_mode_entry->second);
+
+  EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_)).Times(1);
+  observer.reset();
+}
 
 TEST_F(MediaRouterUITest, GetExtensionNameExtensionPresent) {
   std::string id = "extensionid";
   GURL url = GURL("chrome-extension://" + id);
   std::unique_ptr<extensions::ExtensionRegistry> registry =
       base::WrapUnique(new extensions::ExtensionRegistry(nullptr));
   scoped_refptr<extensions::Extension> app =
       extensions::test_util::BuildApp(extensions::ExtensionBuilder())
           .MergeManifest(extensions::DictionaryBuilder()
                              .Set("name", "test app name")
@@ skipping 16 matching lines @@
 }
 
 TEST_F(MediaRouterUITest, GetExtensionNameEmptyWhenNotExtensionURL) {
   GURL url = GURL("https://www.google.com");
   std::unique_ptr<extensions::ExtensionRegistry> registry =
       base::WrapUnique(new extensions::ExtensionRegistry(nullptr));
 
   EXPECT_EQ("", MediaRouterUI::GetExtensionName(url, registry.get()));
 }
 }  // namespace media_router