Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

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 223 matching lines @@
       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()->CallJavascriptFunction(kSetSinkListAndIdentity,
-                                   *sinks_and_identity_val);
+  web_ui()->CallJavascriptFunctionUnsafe(kSetSinkListAndIdentity,
+                                         *sinks_and_identity_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateRoutes(
     const std::vector<MediaRoute>& routes,
     const std::vector<MediaRoute::Id>& joinable_route_ids) {
   std::unique_ptr<base::ListValue> routes_val(
       RoutesToValue(routes, joinable_route_ids));
-  web_ui()->CallJavascriptFunction(kSetRouteList, *routes_val);
+  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()->CallJavascriptFunction(kSetCastModeList, *cast_modes_val);
+  web_ui()->CallJavascriptFunctionUnsafe(kSetCastModeList, *cast_modes_val);
 }
 
 void MediaRouterWebUIMessageHandler::OnCreateRouteResponseReceived(
     const MediaSink::Id& sink_id,
     const MediaRoute* route) {
   DVLOG(2) << "OnCreateRouteResponseReceived";
   if (route) {
     std::unique_ptr<base::DictionaryValue> route_value(RouteToValue(
         *route, false, media_router_ui_->GetRouteProviderExtensionId(),
         off_the_record_));
-    web_ui()->CallJavascriptFunction(
-        kOnCreateRouteResponseReceived,
-        base::StringValue(sink_id), *route_value,
-        base::FundamentalValue(route->for_display()));
+    web_ui()->CallJavascriptFunctionUnsafe(
+        kOnCreateRouteResponseReceived, base::StringValue(sink_id),
+        *route_value, base::FundamentalValue(route->for_display()));
   } else {
-    web_ui()->CallJavascriptFunction(kOnCreateRouteResponseReceived,
-                                     base::StringValue(sink_id),
-                                     *base::Value::CreateNullValue(),
-                                     base::FundamentalValue(false));
+    web_ui()->CallJavascriptFunctionUnsafe(
+        kOnCreateRouteResponseReceived, base::StringValue(sink_id),
+        *base::Value::CreateNullValue(), base::FundamentalValue(false));
   }
 }
 
 void MediaRouterWebUIMessageHandler::ReturnSearchResult(
     const std::string& sink_id) {
   DVLOG(2) << "ReturnSearchResult";
-  web_ui()->CallJavascriptFunction(kReceiveSearchResult,
-                                   base::StringValue(sink_id));
+  web_ui()->CallJavascriptFunctionUnsafe(kReceiveSearchResult,
+                                         base::StringValue(sink_id));
 }
 
 void MediaRouterWebUIMessageHandler::UpdateIssue(const Issue* issue) {
   DVLOG(2) << "UpdateIssue";
-  web_ui()->CallJavascriptFunction(kSetIssue,
+  web_ui()->CallJavascriptFunctionUnsafe(
+      kSetIssue,
       issue ? *IssueToValue(*issue) : *base::Value::CreateNullValue());
 }
 
 void MediaRouterWebUIMessageHandler::UpdateMaxDialogHeight(int height) {
   DVLOG(2) << "UpdateMaxDialogHeight";
-  web_ui()->CallJavascriptFunction(kUpdateMaxHeight,
-                                   base::FundamentalValue(height));
+  web_ui()->CallJavascriptFunctionUnsafe(kUpdateMaxHeight,
+                                         base::FundamentalValue(height));
 }
 
 void MediaRouterWebUIMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       kRequestInitialData,
       base::Bind(&MediaRouterWebUIMessageHandler::OnRequestInitialData,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kCreateRoute,
       base::Bind(&MediaRouterWebUIMessageHandler::OnCreateRoute,
@@ skipping 93 matching lines @@
 
   std::unique_ptr<base::ListValue> routes(RoutesToValue(
       media_router_ui_->routes(), media_router_ui_->joinable_route_ids()));
   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()->CallJavascriptFunction(kSetInitialData, initial_data);
+  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;
   if (!args->GetDictionary(0, &args_dict) ||
@@ skipping 346 matching lines @@
 
 bool MediaRouterWebUIMessageHandler::ActOnIssueType(
     const IssueAction::Type& action_type,
     const base::DictionaryValue* args) {
   if (action_type == IssueAction::TYPE_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);
     open_args->AppendString(learn_more_url);
-    web_ui()->CallJavascriptFunction(kWindowOpen, *open_args);
+    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() {
   base::DictionaryValue first_run_flow_data;
 
@@ skipping 36 matching lines @@
   // Return early if the first run flow won't be surfaced.
   if (first_run_flow_acknowledged && !show_cloud_pref)
     return;
 
   // General Chromecast learn more page.
   first_run_flow_data.SetString("firstRunFlowLearnMoreUrl",
                                 kCastLearnMorePageUrl);
   first_run_flow_data.SetBoolean("wasFirstRunFlowAcknowledged",
                                  first_run_flow_acknowledged);
   first_run_flow_data.SetBoolean("showFirstRunFlowCloudPref", show_cloud_pref);
-  web_ui()->CallJavascriptFunction(kSetFirstRunFlowData, first_run_flow_data);
+  web_ui()->CallJavascriptFunctionUnsafe(kSetFirstRunFlowData,
+                                         first_run_flow_data);
 }
 
 AccountInfo MediaRouterWebUIMessageHandler::GetAccountInfo() {
 #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)
 
@@ skipping 15 matching lines @@
   }
 
   return value;
 }
 
 void MediaRouterWebUIMessageHandler::SetWebUIForTest(content::WebUI* web_ui) {
   set_web_ui(web_ui);
 }
 
 }  // namespace media_router