[Media Router] Force DEFAULT cast mode when starting presentations from content.

chrome/browser/ui/webui/media_router/media_router_webui_message_handler_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_webui_message_handler.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_test.h"
 #include "chrome/browser/ui/browser_commands.h"
@@ skipping 150 matching lines @@
     web_ui_.reset();
     BrowserWithTestWindowTest::TearDown();
   }
 
   const std::string& provider_extension_id() const {
     return provider_extension_id_;
   }
 
   // Gets the call data for the function call made to |web_ui_|. There needs
   // to be one call made, and its function name must be |function_name|.
-  const content::TestWebUI::CallData& GetCallData(
-      const std::string& function_name) {
-    EXPECT_EQ(1u, web_ui_->call_data().size());
+  const base::Value* GetCallData(const std::string& function_name) {
+    CHECK(1u == web_ui_->call_data().size());
     const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
-    EXPECT_EQ(function_name, call_data.function_name());
-
-    return call_data;
+    CHECK(function_name == call_data.function_name());
+    return call_data.arg1();
   }
 
   // Gets the dictionary passed into a call to the |web_ui_| as the argument.
   // There needs to be one call made, and its function name must be
   // |function_name|.
   const base::DictionaryValue* ExtractDictFromCallArg(
       const std::string& function_name) {
-    const content::TestWebUI::CallData& call_data = GetCallData(function_name);
-    const base::Value* arg1 = call_data.arg1();
     const base::DictionaryValue* dict_value = nullptr;
-    CHECK(arg1->GetAsDictionary(&dict_value));
+    CHECK(GetCallData(function_name)->GetAsDictionary(&dict_value));
+    return dict_value;
+  }
 
-    return dict_value;
+  // Gets the list passed into a call to the |web_ui_| as the argument.
+  // There needs to be one call made, and its function name must be
+  // |function_name|.
+  const base::ListValue* ExtractListFromCallArg(
+      const std::string& function_name) {
+    const base::ListValue* list_value = nullptr;
+    CHECK(GetCallData(function_name)->GetAsList(&list_value));
+    return list_value;
   }
 
   // Gets the first element of the list passed in as the argument to a call to
   // the |web_ui_| as a dictionary. There needs to be one call made, and its
   // function name must be |function_name|.
   const base::DictionaryValue* ExtractDictFromListFromCallArg(
       const std::string& function_name) {
-    const content::TestWebUI::CallData& call_data = GetCallData(function_name);
-    const base::Value* arg1 = call_data.arg1();
     const base::ListValue* list_value = nullptr;
-    CHECK(arg1->GetAsList(&list_value));
+    CHECK(GetCallData(function_name)->GetAsList(&list_value));
     const base::DictionaryValue* dict_value = nullptr;
     CHECK(list_value->GetDictionary(0, &dict_value));
-
     return dict_value;
   }
 
  protected:
   std::unique_ptr<content::TestWebUI> web_ui_;
   std::unique_ptr<MockMediaRouterUI> mock_media_router_ui_;
   std::unique_ptr<TestMediaRouterWebUIMessageHandler> handler_;
   const std::string provider_extension_id_;
 };
 
@@ skipping 160 matching lines @@
   EXPECT_FALSE(GetBooleanFromDict(route_value, "canJoin"));
 
   int actual_current_cast_mode = -1;
   EXPECT_FALSE(
       route_value->GetInteger("currentCastMode", &actual_current_cast_mode));
   std::string custom_controller_path;
   EXPECT_FALSE(
       route_value->GetString("customControllerPath", &custom_controller_path));
 }
 
+TEST_F(MediaRouterWebUIMessageHandlerTest, SetCastModesList) {
+  CastModeSet cast_modes({MediaCastMode::DEFAULT, MediaCastMode::TAB_MIRROR,
+                          MediaCastMode::DESKTOP_MIRROR});
+  handler_->UpdateCastModes(cast_modes, "www.host.com", MediaCastMode::DEFAULT);
+  const base::ListValue* set_cast_mode_list =
+      ExtractListFromCallArg("media_router.ui.setCastModeList");
+
+  const base::DictionaryValue* cast_mode = nullptr;
+  size_t index = 0;
+  for (auto i = cast_modes.begin(); i != cast_modes.end(); i++) {
+    CHECK(set_cast_mode_list->GetDictionary(index++, &cast_mode));
+    EXPECT_EQ(static_cast<int>(*i), GetIntegerFromDict(cast_mode, "type"));
+    EXPECT_EQ(MediaCastModeToDescription(*i, "www.host.com"),
+              GetStringFromDict(cast_mode, "description"));
+    EXPECT_EQ("www.host.com", GetStringFromDict(cast_mode, "host"));
+    EXPECT_EQ(*i == MediaCastMode::DEFAULT,
+              GetBooleanFromDict(cast_mode, "isForced"));
+  }
+}
+
 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateMediaRouteStatus) {
   MediaStatus status;
   status.title = "test title";
   status.description = "test description";
   status.can_play_pause = true;
   status.can_set_volume = true;
   status.is_paused = true;
   status.duration = base::TimeDelta::FromSeconds(90);
   status.current_time = base::TimeDelta::FromSeconds(80);
   status.volume = 0.9;
@@ skipping 20 matching lines @@
 }
 
 TEST_F(MediaRouterWebUIMessageHandlerTest, OnCreateRouteResponseReceived) {
   MediaRoute route = CreateRoute();
   bool incognito = false;
   route.set_incognito(incognito);
 
   EXPECT_CALL(*mock_media_router_ui_, GetRouteProviderExtensionId())
       .WillOnce(ReturnRef(provider_extension_id()));
   handler_->OnCreateRouteResponseReceived(route.media_sink_id(), &route);
-  const content::TestWebUI::CallData& call_data =
-      GetCallData("media_router.ui.onCreateRouteResponseReceived");
-  const base::Value* sink_id_value = nullptr;
+
+  const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
+  EXPECT_EQ("media_router.ui.onCreateRouteResponseReceived",
+            call_data.function_name());
+  std::string sink_id_value;
   ASSERT_TRUE(call_data.arg1()->GetAsString(&sink_id_value));
-  EXPECT_EQ(route.media_sink_id(), sink_id_value->GetString());
+  EXPECT_EQ(route.media_sink_id(), sink_id_value);
 
   const base::DictionaryValue* route_value = nullptr;
   ASSERT_TRUE(call_data.arg2()->GetAsDictionary(&route_value));
   EXPECT_EQ(route.media_route_id(), GetStringFromDict(route_value, "id"));
   EXPECT_EQ(route.media_sink_id(), GetStringFromDict(route_value, "sinkId"));
   EXPECT_EQ(route.description(), GetStringFromDict(route_value, "description"));
   EXPECT_EQ(route.is_local(), GetBooleanFromDict(route_value, "isLocal"));
   std::string expected_path = base::StringPrintf(
       "%s://%s/%s", extensions::kExtensionScheme,
       kProviderExtensionIdForTesting, kControllerPathForTesting);
   EXPECT_EQ(expected_path,
             GetStringFromDict(route_value, "customControllerPath"));
 
   bool route_for_display = false;
   ASSERT_TRUE(call_data.arg3()->GetAsBoolean(&route_for_display));
   EXPECT_TRUE(route_for_display);
 }
 
 TEST_F(MediaRouterWebUIMessageHandlerTest,
        OnCreateRouteResponseReceivedIncognito) {
   handler_->set_incognito_for_test(true);
   MediaRoute route = CreateRoute();
   bool incognito = true;
   route.set_incognito(incognito);
 
   EXPECT_CALL(*mock_media_router_ui_, GetRouteProviderExtensionId()).WillOnce(
       ReturnRef(provider_extension_id()));
   handler_->OnCreateRouteResponseReceived(route.media_sink_id(), &route);
-  const content::TestWebUI::CallData& call_data =
-      GetCallData("media_router.ui.onCreateRouteResponseReceived");
-  const base::Value* sink_id_value = nullptr;
+
+  const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
+  EXPECT_EQ("media_router.ui.onCreateRouteResponseReceived",
+            call_data.function_name());
+  std::string sink_id_value;
   ASSERT_TRUE(call_data.arg1()->GetAsString(&sink_id_value));
-  EXPECT_EQ(route.media_sink_id(), sink_id_value->GetString());
+  EXPECT_EQ(route.media_sink_id(), sink_id_value);
 
   const base::DictionaryValue* route_value = nullptr;
   ASSERT_TRUE(call_data.arg2()->GetAsDictionary(&route_value));
   EXPECT_EQ(route.media_route_id(), GetStringFromDict(route_value, "id"));
   EXPECT_EQ(route.media_sink_id(), GetStringFromDict(route_value, "sinkId"));
   EXPECT_EQ(route.description(), GetStringFromDict(route_value, "description"));
   EXPECT_EQ(route.is_local(), GetBooleanFromDict(route_value, "isLocal"));
 
   std::string actual_path;
   EXPECT_FALSE(route_value->GetString("customControllerPath", &actual_path));
@@ skipping 179 matching lines @@
 
 TEST_F(MediaRouterWebUIMessageHandlerTest, OnRouteControllerInvalidated) {
   handler_->OnRouteControllerInvalidated();
   EXPECT_EQ(1u, web_ui_->call_data().size());
   const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
   EXPECT_EQ("media_router.ui.onRouteControllerInvalidated",
             call_data.function_name());
 }
 
 }  // namespace media_router