Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

chrome/browser/ui/webui/signin/user_manager_screen_handler.cc

 // Copyright 2013 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/signin/user_manager_screen_handler.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
@@ skipping 279 matching lines @@
       new UserManagerScreenHandler::ProfileUpdateObserver(
           g_browser_process->profile_manager(), this));
 }
 
 UserManagerScreenHandler::~UserManagerScreenHandler() {
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 }
 
 void UserManagerScreenHandler::ShowBannerMessage(
     const base::string16& message) {
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "login.AccountPickerScreen.showBannerMessage",
       base::StringValue(message));
 }
 
 void UserManagerScreenHandler::ShowUserPodCustomIcon(
     const AccountId& account_id,
     const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions&
         icon_options) {
   std::unique_ptr<base::DictionaryValue> icon =
       icon_options.ToDictionaryValue();
   if (!icon || icon->empty())
     return;
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "login.AccountPickerScreen.showUserPodCustomIcon",
       base::StringValue(account_id.GetUserEmail()), *icon);
 }
 
 void UserManagerScreenHandler::HideUserPodCustomIcon(
     const AccountId& account_id) {
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "login.AccountPickerScreen.hideUserPodCustomIcon",
       base::StringValue(account_id.GetUserEmail()));
 }
 
 void UserManagerScreenHandler::EnableInput() {
   // Nothing here because UI is not disabled when starting to authenticate.
 }
 
 void UserManagerScreenHandler::SetAuthType(
     const AccountId& account_id,
     proximity_auth::ScreenlockBridge::LockHandler::AuthType auth_type,
     const base::string16& auth_value) {
   if (GetAuthType(account_id) ==
       proximity_auth::ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD)
     return;
 
   user_auth_type_map_[account_id.GetUserEmail()] = auth_type;
-  web_ui()->CallJavascriptFunction("login.AccountPickerScreen.setAuthType",
-                                   base::StringValue(account_id.GetUserEmail()),
-                                   base::FundamentalValue(auth_type),
-                                   base::StringValue(auth_value));
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "login.AccountPickerScreen.setAuthType",
+      base::StringValue(account_id.GetUserEmail()),
+      base::FundamentalValue(auth_type), base::StringValue(auth_value));
 }
 
 proximity_auth::ScreenlockBridge::LockHandler::AuthType
 UserManagerScreenHandler::GetAuthType(const AccountId& account_id) const {
   const auto it = user_auth_type_map_.find(account_id.GetUserEmail());
   if (it == user_auth_type_map_.end())
     return proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
   return it->second;
 }
 
@@ skipping 15 matching lines @@
                                                  const std::string& secret,
                                                  const std::string& key_label) {
   NOTREACHED();
 }
 
 void UserManagerScreenHandler::HandleInitialize(const base::ListValue* args) {
   // If the URL has a hash parameter, store it for later.
   args->GetString(0, &url_hash_);
 
   SendUserList();
-  web_ui()->CallJavascriptFunction("cr.ui.UserManager.showUserManagerScreen",
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "cr.ui.UserManager.showUserManagerScreen",
       base::FundamentalValue(IsGuestModeEnabled()),
       base::FundamentalValue(IsAddPersonEnabled()));
 
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(this);
 }
 
 void UserManagerScreenHandler::HandleAddUser(const base::ListValue* args) {
   if (!IsAddPersonEnabled()) {
     // The 'Add User' UI should not be showing.
     NOTREACHED();
@@ skipping 73 matching lines @@
 
   base::FilePath profile_path;
   if (!base::GetValueAsFilePath(*profile_path_value, &profile_path)) {
     NOTREACHED();
     return;
   }
 
   DCHECK(profiles::IsMultipleProfilesEnabled());
 
   if (profiles::AreAllProfilesLocked()) {
-    web_ui()->CallJavascriptFunction(
-        "cr.webUIListenerCallback",
-        base::StringValue("show-error-dialog"),
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "cr.webUIListenerCallback", base::StringValue("show-error-dialog"),
         base::StringValue(l10n_util::GetStringUTF8(
             IDS_USER_MANAGER_REMOVE_PROFILE_PROFILES_LOCKED_ERROR)));
     return;
   }
 
   // The callback is run if the only profile has been deleted, and a new
   // profile has been created to replace it.
   webui::DeleteProfileAtPath(profile_path,
                              web_ui(),
                              ProfileMetrics::DELETE_PROFILE_USER_MANAGER);
@@ skipping 11 matching lines @@
   }
 }
 
 void UserManagerScreenHandler::HandleAreAllProfilesLocked(
     const base::ListValue* args) {
   std::string webui_callback_id;
   CHECK_EQ(1U, args->GetSize());
   bool success = args->GetString(0, &webui_callback_id);
   DCHECK(success);
 
-  web_ui()->CallJavascriptFunction(
-      "cr.webUIResponse",
-      base::StringValue(webui_callback_id),
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "cr.webUIResponse", base::StringValue(webui_callback_id),
       base::FundamentalValue(true),
       base::FundamentalValue(profiles::AreAllProfilesLocked()));
 }
 
 void UserManagerScreenHandler::HandleLaunchUser(const base::ListValue* args) {
   const base::Value* profile_path_value = NULL;
   if (!args->Get(0, &profile_path_value))
     return;
 
   base::FilePath profile_path;
@@ skipping 75 matching lines @@
             profile_path);
     bool stats_success = true;
     for (const auto& item : stats) {
       std::unique_ptr<base::DictionaryValue> stat(new base::DictionaryValue);
       stat->SetIntegerWithoutPathExpansion("count", item.count);
       stat->SetBooleanWithoutPathExpansion("success", item.success);
       return_value.SetWithoutPathExpansion(item.category, std::move(stat));
       stats_success &= item.success;
     }
     if (stats_success) {
-      web_ui()->CallJavascriptFunction("updateRemoveWarningDialog",
-                                       base::StringValue(profile_path.value()),
-                                       return_value);
+      web_ui()->CallJavascriptFunctionUnsafe(
+          "updateRemoveWarningDialog", base::StringValue(profile_path.value()),
+          return_value);
       return;
     }
   }
 
   ProfileStatisticsFactory::GetForProfile(profile)->GatherStatistics(
       base::Bind(
           &UserManagerScreenHandler::RemoveUserDialogLoadStatsCallback,
           weak_ptr_factory_.GetWeakPtr(), profile_path));
 }
 
 void UserManagerScreenHandler::RemoveUserDialogLoadStatsCallback(
     base::FilePath profile_path,
     profiles::ProfileCategoryStats result) {
   // Copy result into return_value.
   base::DictionaryValue return_value;
   for (const auto& item : result) {
     std::unique_ptr<base::DictionaryValue> stat(new base::DictionaryValue);
     stat->SetIntegerWithoutPathExpansion("count", item.count);
     stat->SetBooleanWithoutPathExpansion("success", item.success);
     return_value.SetWithoutPathExpansion(item.category, std::move(stat));
   }
-  web_ui()->CallJavascriptFunction("updateRemoveWarningDialog",
-                                   base::StringValue(profile_path.value()),
-                                   return_value);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "updateRemoveWarningDialog", base::StringValue(profile_path.value()),
+      return_value);
 }
 
 void UserManagerScreenHandler::HandleGetRemoveWarningDialogMessage(
     const base::ListValue* args) {
   const base::DictionaryValue* arg;
   if (!args->GetDictionary(0, &arg))
     return;
 
   std::string profile_path("");
   bool is_synced_user = false;
@@ skipping 10 matching lines @@
 
   int message_id = is_synced_user ?
       (has_errors ? IDS_LOGIN_POD_USER_REMOVE_WARNING_SYNC_WITH_ERRORS :
                     IDS_LOGIN_POD_USER_REMOVE_WARNING_SYNC) :
       (has_errors ? IDS_LOGIN_POD_USER_REMOVE_WARNING_NONSYNC_WITH_ERRORS :
                     IDS_LOGIN_POD_USER_REMOVE_WARNING_NONSYNC);
 
   base::StringValue message = base::StringValue(
       l10n_util::GetPluralStringFUTF16(message_id, total_count));
 
-  web_ui()->CallJavascriptFunction("updateRemoveWarningDialogSetMessage",
-                                   base::StringValue(profile_path),
-                                   message,
-                                   base::FundamentalValue(total_count));
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "updateRemoveWarningDialogSetMessage", base::StringValue(profile_path),
+      message, base::FundamentalValue(total_count));
 }
 
 void UserManagerScreenHandler::OnGetTokenInfoResponse(
     std::unique_ptr<base::DictionaryValue> token_info) {
   // Password is unchanged so user just mistyped it.  Ask again.
   ReportAuthenticationResult(false, ProfileMetrics::AUTH_FAILED);
 }
 
 void UserManagerScreenHandler::OnOAuthError() {
   // Password has changed.  Go through online signin flow.
@@ skipping 248 matching lines @@
 
     // GetProfileByPath returns a pointer if the profile is fully loaded, NULL
     // otherwise.
     Profile* profile =
         g_browser_process->profile_manager()->GetProfileByPath(profile_path);
     profile_value->SetBoolean(kKeyIsProfileLoaded, profile != nullptr);
 
     users_list.Append(profile_value);
   }
 
-  web_ui()->CallJavascriptFunction("login.AccountPickerScreen.loadUsers",
-      users_list, base::FundamentalValue(IsGuestModeEnabled()));
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "login.AccountPickerScreen.loadUsers", users_list,
+      base::FundamentalValue(IsGuestModeEnabled()));
 
   // This is the latest C++ code we have in the flow to show the UserManager.
   // This may be invoked more than once per UserManager lifetime; the
   // UserManager will ensure all relevant logging only happens once.
   UserManager::OnUserManagerShown();
 }
 
 void UserManagerScreenHandler::ReportAuthenticationResult(
     bool success,
     ProfileMetrics::ProfileAuth auth) {
   ProfileMetrics::LogProfileAuthResult(auth);
   email_address_.clear();
 
   if (success) {
     profiles::SwitchToProfile(
         authenticating_profile_path_, true,
         base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
                    weak_ptr_factory_.GetWeakPtr()),
         ProfileMetrics::SWITCH_PROFILE_UNLOCK);
   } else {
-    web_ui()->CallJavascriptFunction(
-        "cr.ui.UserManager.showSignInError",
-        base::FundamentalValue(0),
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "cr.ui.UserManager.showSignInError", base::FundamentalValue(0),
         base::StringValue(l10n_util::GetStringUTF8(
-            auth == ProfileMetrics::AUTH_FAILED_OFFLINE ?
-                IDS_LOGIN_ERROR_AUTHENTICATING_OFFLINE :
-                IDS_LOGIN_ERROR_AUTHENTICATING)),
-        base::StringValue(""),
-        base::FundamentalValue(0));
+            auth == ProfileMetrics::AUTH_FAILED_OFFLINE
+                ? IDS_LOGIN_ERROR_AUTHENTICATING_OFFLINE
+                : IDS_LOGIN_ERROR_AUTHENTICATING)),
+        base::StringValue(""), base::FundamentalValue(0));
   }
 }
 
 void UserManagerScreenHandler::OnBrowserWindowReady(Browser* browser) {
   DCHECK(browser);
   DCHECK(browser->window());
 
   // Unlock the profile after browser opens so startup can read the lock bit.
   // Any necessary authentication must have been successful to reach this point.
   if (!browser->profile()->IsGuestSession()) {
@@ skipping 42 matching lines @@
     Profile* profile, Profile::CreateStatus profile_create_status) {
   Browser* browser = chrome::FindAnyBrowser(profile, false);
   if (browser && browser->window()) {
     OnBrowserWindowReady(browser);
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }