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

chrome/browser/ui/webui/media_router/media_router_webui_message_handler.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 <string>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 123 matching lines @@
   sink_list_and_identity->Set("sinks", sinks_val.release());
   sink_list_and_identity->SetBoolean("showEmail", show_email);
   sink_list_and_identity->SetBoolean("showDomain", show_domain);
   return sink_list_and_identity;
 }
 
 std::unique_ptr<base::DictionaryValue> RouteToValue(
     const MediaRoute& route,
     bool can_join,
     const std::string& extension_id,
-    bool off_the_record) {
+    bool off_the_record,
+    int current_cast_mode) {
   std::unique_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
   dictionary->SetString("id", route.media_route_id());
   dictionary->SetString("sinkId", route.media_sink_id());
   dictionary->SetString("description", route.description());
   dictionary->SetBoolean("isLocal", route.is_local());
   dictionary->SetBoolean("canJoin", can_join);
+  if (current_cast_mode > 0) {
+    dictionary->SetInteger("currentCastMode", current_cast_mode);
+  }
 
   const std::string& custom_path = route.custom_controller_path();
   if (!off_the_record && !custom_path.empty()) {
     std::string full_custom_controller_path = base::StringPrintf("%s://%s/%s",
         extensions::kExtensionScheme, extension_id.c_str(),
             custom_path.c_str());
     DCHECK(GURL(full_custom_controller_path).is_valid());
     dictionary->SetString("customControllerPath",
                           full_custom_controller_path);
   }
@@ skipping 79 matching lines @@
     const std::vector<MediaSinkWithCastModes>& sinks) {
   DVLOG(2) << "UpdateSinks";
   std::unique_ptr<base::DictionaryValue> sinks_and_identity_val(
       SinksAndIdentityToValue(sinks, GetAccountInfo()));
   web_ui()->CallJavascriptFunctionUnsafe(kSetSinkListAndIdentity,
                                          *sinks_and_identity_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateRoutes(
     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_modes) {
   std::unique_ptr<base::ListValue> routes_val(
-      RoutesToValue(routes, joinable_route_ids));
+      RoutesToValue(routes, joinable_route_ids, current_cast_modes));
   web_ui()->CallJavascriptFunctionUnsafe(kSetRouteList, *routes_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateCastModes(
     const CastModeSet& cast_modes,
     const std::string& source_host) {
   DVLOG(2) << "UpdateCastModes";
   std::unique_ptr<base::ListValue> cast_modes_val(
       CastModesToValue(cast_modes, source_host));
   web_ui()->CallJavascriptFunctionUnsafe(kSetCastModeList, *cast_modes_val);
 }
 
 void MediaRouterWebUIMessageHandler::OnCreateRouteResponseReceived(
     const MediaSink::Id& sink_id,
     const MediaRoute* route) {
   DVLOG(2) << "OnCreateRouteResponseReceived";
   if (route) {
+    int current_cast_mode = CurrentCastModeForRouteId(
+        route->media_route_id(), media_router_ui_->current_cast_modes());
     std::unique_ptr<base::DictionaryValue> route_value(RouteToValue(
         *route, false, media_router_ui_->GetRouteProviderExtensionId(),
-        off_the_record_));
+        off_the_record_, current_cast_mode));
     web_ui()->CallJavascriptFunctionUnsafe(
         kOnCreateRouteResponseReceived, base::StringValue(sink_id),
         *route_value, base::FundamentalValue(route->for_display()));
   } else {
     web_ui()->CallJavascriptFunctionUnsafe(
         kOnCreateRouteResponseReceived, base::StringValue(sink_id),
         *base::Value::CreateNullValue(), base::FundamentalValue(false));
   }
 }
 
@@ skipping 113 matching lines @@
 
   // "No Cast devices found?" Chromecast help center page.
   initial_data.SetString("deviceMissingUrl",
       base::StringPrintf(kHelpPageUrlPrefix, 3249268));
 
   std::unique_ptr<base::DictionaryValue> sinks_and_identity(
       SinksAndIdentityToValue(media_router_ui_->sinks(), GetAccountInfo()));
   initial_data.Set("sinksAndIdentity", sinks_and_identity.release());
 
   std::unique_ptr<base::ListValue> routes(RoutesToValue(
-      media_router_ui_->routes(), media_router_ui_->joinable_route_ids()));
+      media_router_ui_->routes(), media_router_ui_->joinable_route_ids(),
+      media_router_ui_->current_cast_modes()));
   initial_data.Set("routes", routes.release());
 
   const std::set<MediaCastMode> cast_modes = media_router_ui_->cast_modes();
   std::unique_ptr<base::ListValue> cast_modes_list(CastModesToValue(
       cast_modes, media_router_ui_->GetPresentationRequestSourceName()));
   initial_data.Set("castModes", cast_modes_list.release());
 
   web_ui()->CallJavascriptFunctionUnsafe(kSetInitialData, initial_data);
   media_router_ui_->UIInitialized();
 }
@@ skipping 426 matching lines @@
 #if defined(GOOGLE_CHROME_BUILD)
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(Profile::FromWebUI(web_ui()));
   if (signin_manager)
     return signin_manager->GetAuthenticatedAccountInfo();
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
   return AccountInfo();
 }
 
+int MediaRouterWebUIMessageHandler::CurrentCastModeForRouteId(
+    const MediaRoute::Id& route_id,
+    const std::unordered_map<MediaRoute::Id, MediaCastMode>& current_cast_modes)
+    const {
+  auto current_cast_mode_entry = current_cast_modes.find(route_id);
+  int current_cast_mode = current_cast_mode_entry != current_cast_modes.end()
+                              ? current_cast_mode_entry->second
+                              : -1;
+  return current_cast_mode;
+}
+
 std::unique_ptr<base::ListValue> MediaRouterWebUIMessageHandler::RoutesToValue(
     const std::vector<MediaRoute>& routes,
-    const std::vector<MediaRoute::Id>& joinable_route_ids) const {
+    const std::vector<MediaRoute::Id>& joinable_route_ids,
+    const std::unordered_map<MediaRoute::Id, MediaCastMode>& current_cast_modes)
+    const {
   std::unique_ptr<base::ListValue> value(new base::ListValue);
   const std::string& extension_id =
       media_router_ui_->GetRouteProviderExtensionId();
 
   for (const MediaRoute& route : routes) {
     bool can_join = ContainsValue(joinable_route_ids, route.media_route_id());
-    std::unique_ptr<base::DictionaryValue> route_val(
-        RouteToValue(route, can_join, extension_id, off_the_record_));
+    int current_cast_mode = CurrentCastModeForRouteId(route.media_route_id(),
+                                                      current_cast_modes);
+    std::unique_ptr<base::DictionaryValue> route_val(RouteToValue(
+        route, can_join, extension_id, off_the_record_, current_cast_mode));
     value->Append(route_val.release());
   }
 
   return value;
 }
 
 void MediaRouterWebUIMessageHandler::SetWebUIForTest(content::WebUI* web_ui) {
   set_web_ui(web_ui);
 }
 
 }  // namespace media_router