Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

components/proximity_auth/webui/proximity_auth_webui_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 "components/proximity_auth/webui/proximity_auth_webui_handler.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/base64url.h"
@@ skipping 147 matching lines @@
   web_ui()->RegisterMessageCallback(
       "toggleConnection",
       base::Bind(&ProximityAuthWebUIHandler::ToggleConnection,
                  base::Unretained(this)));
 }
 
 void ProximityAuthWebUIHandler::OnLogMessageAdded(
     const LogBuffer::LogMessage& log_message) {
   std::unique_ptr<base::DictionaryValue> dictionary =
       LogMessageToDictionary(log_message);
-  web_ui()->CallJavascriptFunction("LogBufferInterface.onLogMessageAdded",
-                                   *dictionary);
+  web_ui()->CallJavascriptFunctionUnsafe("LogBufferInterface.onLogMessageAdded",
+                                         *dictionary);
 }
 
 void ProximityAuthWebUIHandler::OnLogBufferCleared() {
-  web_ui()->CallJavascriptFunction("LogBufferInterface.onLogBufferCleared");
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "LogBufferInterface.onLogBufferCleared");
 }
 
 void ProximityAuthWebUIHandler::OnEnrollmentStarted() {
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "LocalStateInterface.onEnrollmentStateChanged",
       *GetEnrollmentStateDictionary());
 }
 
 void ProximityAuthWebUIHandler::OnEnrollmentFinished(bool success) {
   std::unique_ptr<base::DictionaryValue> enrollment_state =
       GetEnrollmentStateDictionary();
   PA_LOG(INFO) << "Enrollment attempt completed with success=" << success
                << ":\n" << *enrollment_state;
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "LocalStateInterface.onEnrollmentStateChanged", *enrollment_state);
 }
 
 void ProximityAuthWebUIHandler::OnSyncStarted() {
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "LocalStateInterface.onDeviceSyncStateChanged",
       *GetDeviceSyncStateDictionary());
 }
 
 void ProximityAuthWebUIHandler::OnSyncFinished(
     CryptAuthDeviceManager::SyncResult sync_result,
     CryptAuthDeviceManager::DeviceChangeResult device_change_result) {
   std::unique_ptr<base::DictionaryValue> device_sync_state =
       GetDeviceSyncStateDictionary();
   PA_LOG(INFO) << "Device sync completed with result="
                << static_cast<int>(sync_result) << ":\n" << *device_sync_state;
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "LocalStateInterface.onDeviceSyncStateChanged", *device_sync_state);
 
   if (device_change_result ==
       CryptAuthDeviceManager::DeviceChangeResult::CHANGED) {
     std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
     PA_LOG(INFO) << "New unlock keys obtained after device sync:\n"
                  << *unlock_keys;
-    web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
-                                     *unlock_keys);
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "LocalStateInterface.onUnlockKeysChanged", *unlock_keys);
   }
 }
 
 void ProximityAuthWebUIHandler::OnWebContentsInitialized(
     const base::ListValue* args) {
   if (!web_contents_initialized_) {
     CryptAuthEnrollmentManager* enrollment_manager =
         proximity_auth_client_->GetCryptAuthEnrollmentManager();
     if (enrollment_manager)
       enrollment_manager->AddObserver(this);
 
     CryptAuthDeviceManager* device_manager =
         proximity_auth_client_->GetCryptAuthDeviceManager();
     if (device_manager)
       device_manager->AddObserver(this);
 
     LogBuffer::GetInstance()->AddObserver(this);
 
     web_contents_initialized_ = true;
   }
 }
 
 void ProximityAuthWebUIHandler::GetLogMessages(const base::ListValue* args) {
   base::ListValue json_logs;
   for (const auto& log : *LogBuffer::GetInstance()->logs()) {
     json_logs.Append(LogMessageToDictionary(log).release());
   }
-  web_ui()->CallJavascriptFunction("LogBufferInterface.onGotLogMessages",
-                                   json_logs);
+  web_ui()->CallJavascriptFunctionUnsafe("LogBufferInterface.onGotLogMessages",
+                                         json_logs);
 }
 
 void ProximityAuthWebUIHandler::ClearLogBuffer(const base::ListValue* args) {
   // The OnLogBufferCleared() observer function will be called after the buffer
   // is cleared.
   LogBuffer::GetInstance()->Clear();
 }
 
 void ProximityAuthWebUIHandler::ToggleUnlockKey(const base::ListValue* args) {
   std::string public_key_b64, public_key;
@@ skipping 107 matching lines @@
     }
   }
 
   PA_LOG(ERROR) << "Unlock key (" << b64_public_key << ") not found";
 }
 
 void ProximityAuthWebUIHandler::OnCryptAuthClientError(
     const std::string& error_message) {
   PA_LOG(WARNING) << "CryptAuth request failed: " << error_message;
   base::StringValue error_string(error_message);
-  web_ui()->CallJavascriptFunction("CryptAuthInterface.onError", error_string);
+  web_ui()->CallJavascriptFunctionUnsafe("CryptAuthInterface.onError",
+                                         error_string);
 }
 
 void ProximityAuthWebUIHandler::OnEasyUnlockToggled(
     const cryptauth::ToggleEasyUnlockResponse& response) {
-  web_ui()->CallJavascriptFunction("CryptAuthInterface.onUnlockKeyToggled");
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "CryptAuthInterface.onUnlockKeyToggled");
   // TODO(tengs): Update the local state to reflect the toggle.
 }
 
 void ProximityAuthWebUIHandler::OnFoundEligibleUnlockDevices(
     const cryptauth::FindEligibleUnlockDevicesResponse& response) {
   base::ListValue eligible_devices;
   for (const auto& external_device : response.eligible_devices()) {
     eligible_devices.Append(ExternalDeviceInfoToDictionary(external_device));
   }
 
   base::ListValue ineligible_devices;
   for (const auto& ineligible_device : response.ineligible_devices()) {
     ineligible_devices.Append(IneligibleDeviceToDictionary(ineligible_device));
   }
 
   PA_LOG(INFO) << "Found " << eligible_devices.GetSize()
                << " eligible devices and " << ineligible_devices.GetSize()
                << " ineligible devices.";
-  web_ui()->CallJavascriptFunction("CryptAuthInterface.onGotEligibleDevices",
-                                   eligible_devices, ineligible_devices);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "CryptAuthInterface.onGotEligibleDevices", eligible_devices,
+      ineligible_devices);
 }
 
 void ProximityAuthWebUIHandler::OnReachablePhonesFound(
     const std::vector<cryptauth::ExternalDeviceInfo>& reachable_phones) {
   reachable_phone_flow_.reset();
   base::ListValue device_list;
   for (const auto& external_device : reachable_phones) {
     device_list.Append(ExternalDeviceInfoToDictionary(external_device));
   }
-  web_ui()->CallJavascriptFunction("CryptAuthInterface.onGotReachableDevices",
-                                   device_list);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "CryptAuthInterface.onGotReachableDevices", device_list);
 }
 
 void ProximityAuthWebUIHandler::GetLocalState(const base::ListValue* args) {
   std::unique_ptr<base::DictionaryValue> enrollment_state =
       GetEnrollmentStateDictionary();
   std::unique_ptr<base::DictionaryValue> device_sync_state =
       GetDeviceSyncStateDictionary();
   std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
 
   PA_LOG(INFO) << "==== Got Local State ====\n"
                << "Enrollment State: \n" << *enrollment_state
                << "Device Sync State: \n" << *device_sync_state
                << "Unlock Keys: \n" << *unlock_keys;
-  web_ui()->CallJavascriptFunction("LocalStateInterface.onGotLocalState",
-                                   *enrollment_state, *device_sync_state,
-                                   *unlock_keys);
+  web_ui()->CallJavascriptFunctionUnsafe("LocalStateInterface.onGotLocalState",
+                                         *enrollment_state, *device_sync_state,
+                                         *unlock_keys);
 }
 
 std::unique_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::GetEnrollmentStateDictionary() {
   CryptAuthEnrollmentManager* enrollment_manager =
       proximity_auth_client_->GetCryptAuthEnrollmentManager();
   if (!enrollment_manager)
     return base::WrapUnique(new base::DictionaryValue());
 
   return CreateSyncStateDictionary(
@@ skipping 128 matching lines @@
                          std::move(ineligibility_reasons));
   return device_dictionary;
 }
 
 void ProximityAuthWebUIHandler::CleanUpRemoteDeviceLifeCycle() {
   PA_LOG(INFO) << "Cleaning up connection to " << selected_remote_device_.name
                << " [" << selected_remote_device_.bluetooth_address << "]";
   life_cycle_.reset();
   selected_remote_device_ = RemoteDevice();
   last_remote_status_update_.reset();
-  web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
-                                   *GetUnlockKeysList());
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "LocalStateInterface.onUnlockKeysChanged", *GetUnlockKeysList());
 }
 
 void ProximityAuthWebUIHandler::OnLifeCycleStateChanged(
     RemoteDeviceLifeCycle::State old_state,
     RemoteDeviceLifeCycle::State new_state) {
   // Do not re-attempt to find a connection after the first one fails--just
   // abort.
   if ((old_state != RemoteDeviceLifeCycle::State::STOPPED &&
        new_state == RemoteDeviceLifeCycle::State::FINDING_CONNECTION) ||
       new_state == RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED) {
     // Clean up the life cycle asynchronously, because we are currently in the
     // call stack of |life_cycle_|.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&ProximityAuthWebUIHandler::CleanUpRemoteDeviceLifeCycle,
                    weak_ptr_factory_.GetWeakPtr()));
   } else if (new_state ==
              RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
     life_cycle_->GetMessenger()->AddObserver(this);
   }
 
-  web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
-                                   *GetUnlockKeysList());
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "LocalStateInterface.onUnlockKeysChanged", *GetUnlockKeysList());
 }
 
 void ProximityAuthWebUIHandler::OnRemoteStatusUpdate(
     const RemoteStatusUpdate& status_update) {
   PA_LOG(INFO) << "Remote status update:"
                << "\n  user_presence: "
                << static_cast<int>(status_update.user_presence)
                << "\n  secure_screen_lock_state: "
                << static_cast<int>(status_update.secure_screen_lock_state)
                << "\n  trust_agent_state: "
                << static_cast<int>(status_update.trust_agent_state);
 
   last_remote_status_update_.reset(new RemoteStatusUpdate(status_update));
   std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
-  web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
-                                   *unlock_keys);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "LocalStateInterface.onUnlockKeysChanged", *unlock_keys);
 }
 
 }  // namespace proximity_auth