[Media Router] Add a supports_web_ui_controller attribute to MediaRoute

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 <memory>
 #include <string>
 #include <utility>
 
@@ skipping 76 matching lines @@
 const char kSetCastModeList[] = "media_router.ui.setCastModeList";
 const char kUpdateMaxHeight[] = "media_router.ui.updateMaxHeight";
 const char kUpdateRouteStatus[] = "media_router.ui.updateRouteStatus";
 const char kUserSelectedLocalMediaFile[] =
     "media_router.ui.userSelectedLocalMediaFile";
 const char kWindowOpen[] = "window.open";
 
 std::unique_ptr<base::DictionaryValue> SinksAndIdentityToValue(
     const std::vector<MediaSinkWithCastModes>& sinks,
     const AccountInfo& account_info) {
-  std::unique_ptr<base::DictionaryValue> sink_list_and_identity(
-      new base::DictionaryValue);
+  auto sink_list_and_identity = base::MakeUnique<base::DictionaryValue>();
   bool show_email = false;
   bool show_domain = false;
   std::string user_domain;
   if (account_info.IsValid()) {
     user_domain = account_info.hosted_domain;
     sink_list_and_identity->SetString("userEmail", account_info.email);
   }
 
-  std::unique_ptr<base::ListValue> sinks_val(new base::ListValue);
+  auto sinks_val = base::MakeUnique<base::ListValue>();
 
   for (const MediaSinkWithCastModes& sink_with_cast_modes : sinks) {
-    std::unique_ptr<base::DictionaryValue> sink_val(new base::DictionaryValue);
+    auto sink_val = base::MakeUnique<base::DictionaryValue>();
 
     const MediaSink& sink = sink_with_cast_modes.sink;
     sink_val->SetString("id", sink.id());
     sink_val->SetString("name", sink.name());
     sink_val->SetInteger("iconType", sink.icon_type());
     if (sink.description())
       sink_val->SetString("description", *sink.description());
 
     bool is_pseudo_sink =
         base::StartsWith(sink.id(), "pseudo:", base::CompareCase::SENSITIVE);
@@ skipping 29 matching lines @@
   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 incognito,
-    int current_cast_mode) {
-  std::unique_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
+    int current_cast_mode,
+    bool is_web_ui_route_controller_available) {
+  auto dictionary = base::MakeUnique<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("supportsWebUiController",
+                         is_web_ui_route_controller_available &&
+                             route.supports_media_route_controller());
   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 (!incognito && !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);
   }
 
   return dictionary;
 }
 
 std::unique_ptr<base::ListValue> CastModesToValue(
     const CastModeSet& cast_modes,
     const std::string& source_host,
     base::Optional<MediaCastMode> forced_cast_mode) {
-  std::unique_ptr<base::ListValue> value(new base::ListValue);
+  auto value = base::MakeUnique<base::ListValue>();
 
   for (const MediaCastMode& cast_mode : cast_modes) {
-    std::unique_ptr<base::DictionaryValue> cast_mode_val(
-        new base::DictionaryValue);
+    auto cast_mode_val = base::MakeUnique<base::DictionaryValue>();
     cast_mode_val->SetInteger("type", cast_mode);
     cast_mode_val->SetString(
         "description", MediaCastModeToDescription(cast_mode, source_host));
     cast_mode_val->SetString("host", source_host);
     cast_mode_val->SetBoolean(
         "isForced", forced_cast_mode && forced_cast_mode == cast_mode);
     value->Append(std::move(cast_mode_val));
   }
 
   return value;
 }
 
 // Returns an Issue dictionary created from |issue| that can be used in WebUI.
 std::unique_ptr<base::DictionaryValue> IssueToValue(const Issue& issue) {
   const IssueInfo& issue_info = issue.info();
-  std::unique_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
+  auto dictionary = base::MakeUnique<base::DictionaryValue>();
   dictionary->SetInteger("id", issue.id());
   dictionary->SetString("title", issue_info.title);
   dictionary->SetString("message", issue_info.message);
   dictionary->SetInteger("defaultActionType",
                          static_cast<int>(issue_info.default_action));
   if (!issue_info.secondary_actions.empty()) {
     DCHECK_EQ(1u, issue_info.secondary_actions.size());
     dictionary->SetInteger("secondaryActionType",
                            static_cast<int>(issue_info.secondary_actions[0]));
   }
@@ skipping 31 matching lines @@
   return help_url;
 }
 
 }  // namespace
 
 MediaRouterWebUIMessageHandler::MediaRouterWebUIMessageHandler(
     MediaRouterUI* media_router_ui)
     : incognito_(
           Profile::FromWebUI(media_router_ui->web_ui())->IsOffTheRecord()),
       dialog_closing_(false),
+      is_web_ui_route_controller_available_(base::FeatureList::IsEnabled(
+          features::kMediaRouterUIRouteController)),
       media_router_ui_(media_router_ui) {}
 
 MediaRouterWebUIMessageHandler::~MediaRouterWebUIMessageHandler() {}
 
 void MediaRouterWebUIMessageHandler::UpdateSinks(
     const std::vector<MediaSinkWithCastModes>& sinks) {
   DVLOG(2) << "UpdateSinks";
   std::unique_ptr<base::DictionaryValue> sinks_and_identity_val(
       SinksAndIdentityToValue(sinks, GetAccountInfo()));
   web_ui()->CallJavascriptFunctionUnsafe(kSetSinkListAndIdentity,
@@ skipping 22 matching lines @@
 
 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_->routes_and_cast_modes());
     std::unique_ptr<base::DictionaryValue> route_value(RouteToValue(
         *route, false, media_router_ui_->GetRouteProviderExtensionId(),
-        incognito_, current_cast_mode));
+        incognito_, current_cast_mode, is_web_ui_route_controller_available_));
     web_ui()->CallJavascriptFunctionUnsafe(kOnCreateRouteResponseReceived,
                                            base::Value(sink_id), *route_value,
                                            base::Value(route->for_display()));
   } else {
     web_ui()->CallJavascriptFunctionUnsafe(kOnCreateRouteResponseReceived,
                                            base::Value(sink_id), base::Value(),
                                            base::Value(false));
   }
 }
 
@@ skipping 194 matching lines @@
   initial_data.Set("castModes", std::move(cast_modes_list));
 
   // If the cast mode last chosen for the current origin is tab mirroring,
   // that should be the cast mode initially selected in the dialog. Otherwise
   // the initial cast mode should be chosen automatically by the dialog.
   bool use_tab_mirroring =
       base::ContainsKey(cast_modes, MediaCastMode::TAB_MIRROR) &&
       media_router_ui_->UserSelectedTabMirroringForCurrentOrigin();
   initial_data.SetBoolean("useTabMirroring", use_tab_mirroring);
 
-  initial_data.SetBoolean(
-      "useWebUiRouteControls",
-      base::FeatureList::IsEnabled(features::kMediaRouterUIRouteController));
-
   web_ui()->CallJavascriptFunctionUnsafe(kSetInitialData, initial_data);
   media_router_ui_->UIInitialized();
 }
 
 void MediaRouterWebUIMessageHandler::OnCreateRoute(
     const base::ListValue* args) {
   DVLOG(1) << "OnCreateRoute";
   const base::DictionaryValue* args_dict = nullptr;
   std::string sink_id;
   int cast_mode_num = -1;
@@ skipping 440 matching lines @@
     route_controller->SetVolume(volume);
 }
 
 bool MediaRouterWebUIMessageHandler::ActOnIssueType(
     IssueInfo::Action action_type,
     const base::DictionaryValue* args) {
   if (action_type == IssueInfo::Action::LEARN_MORE) {
     std::string learn_more_url = GetLearnMoreUrl(args);
     if (learn_more_url.empty())
       return false;
-    std::unique_ptr<base::ListValue> open_args(new base::ListValue);
+    auto open_args = base::MakeUnique<base::ListValue>();
     open_args->AppendString(learn_more_url);
     web_ui()->CallJavascriptFunctionUnsafe(kWindowOpen, *open_args);
     return true;
   } else {
     // Do nothing; no other issue action types require any other action.
     return true;
   }
 }
 
 void MediaRouterWebUIMessageHandler::MaybeUpdateFirstRunFlowData() {
@@ skipping 62 matching lines @@
                               ? 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 std::unordered_map<MediaRoute::Id, MediaCastMode>& current_cast_modes)
     const {
-  std::unique_ptr<base::ListValue> value(new base::ListValue);
+  auto value = base::MakeUnique<base::ListValue>();
   const std::string& extension_id =
       media_router_ui_->GetRouteProviderExtensionId();
 
   for (const MediaRoute& route : routes) {
     bool can_join =
         base::ContainsValue(joinable_route_ids, route.media_route_id());
     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, incognito_, current_cast_mode));
+    std::unique_ptr<base::DictionaryValue> route_val(
+        RouteToValue(route, can_join, extension_id, incognito_,
+                     current_cast_mode, is_web_ui_route_controller_available_));
     value->Append(std::move(route_val));
   }
 
   return value;
 }
 
 void MediaRouterWebUIMessageHandler::SetWebUIForTest(content::WebUI* web_ui) {
   set_web_ui(web_ui);
 }
 
 }  // namespace media_router