Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

content/browser/service_worker/service_worker_internals_ui.cc

 // Copyright 2014 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 "content/browser/service_worker/service_worker_internals_ui.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 40 matching lines @@
                                ServiceWorkerStatusCode status) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(OperationCompleteCallback, internals, callback_id, status));
     return;
   }
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (internals) {
-    internals->web_ui()->CallJavascriptFunction(
+    internals->web_ui()->CallJavascriptFunctionUnsafe(
         "serviceworker.onOperationComplete",
         FundamentalValue(static_cast<int>(status)),
         FundamentalValue(callback_id));
   }
 }
 
 void CallServiceWorkerVersionMethodWithVersionID(
     ServiceWorkerInternalsUI::ServiceWorkerVersionMethod method,
     scoped_refptr<ServiceWorkerContextWrapper> context,
     int64_t version_id,
@@ skipping 160 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!internals)
     return;
 
   ScopedVector<const Value> args;
   args.push_back(GetRegistrationListValue(live_registrations));
   args.push_back(GetVersionListValue(live_versions));
   args.push_back(GetRegistrationListValue(stored_registrations));
   args.push_back(new FundamentalValue(partition_id));
   args.push_back(new StringValue(context_path.value()));
-  internals->web_ui()->CallJavascriptFunction("serviceworker.onPartitionData",
-                                              args.get());
+  internals->web_ui()->CallJavascriptFunctionUnsafe(
+      "serviceworker.onPartitionData", args.get());
 }
 
 }  // namespace
 
 class ServiceWorkerInternalsUI::PartitionObserver
     : public ServiceWorkerContextObserver {
  public:
   PartitionObserver(int partition_id, WebUI* web_ui)
       : partition_id_(partition_id), web_ui_(web_ui) {}
   ~PartitionObserver() override {}
   // ServiceWorkerContextObserver overrides:
   void OnRunningStateChanged(int64_t version_id,
                              ServiceWorkerVersion::RunningStatus) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    web_ui_->CallJavascriptFunction(
+    web_ui_->CallJavascriptFunctionUnsafe(
         "serviceworker.onRunningStateChanged", FundamentalValue(partition_id_),
         StringValue(base::Int64ToString(version_id)));
   }
   void OnVersionStateChanged(int64_t version_id,
                              ServiceWorkerVersion::Status) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    web_ui_->CallJavascriptFunction(
-        "serviceworker.onVersionStateChanged",
-        FundamentalValue(partition_id_),
+    web_ui_->CallJavascriptFunctionUnsafe(
+        "serviceworker.onVersionStateChanged", FundamentalValue(partition_id_),
         StringValue(base::Int64ToString(version_id)));
   }
   void OnErrorReported(int64_t version_id,
                        int process_id,
                        int thread_id,
                        const ErrorInfo& info) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     ScopedVector<const Value> args;
     args.push_back(new FundamentalValue(partition_id_));
     args.push_back(new StringValue(base::Int64ToString(version_id)));
     args.push_back(new FundamentalValue(process_id));
     args.push_back(new FundamentalValue(thread_id));
     std::unique_ptr<DictionaryValue> value(new DictionaryValue());
     value->SetString("message", info.error_message);
     value->SetInteger("lineNumber", info.line_number);
     value->SetInteger("columnNumber", info.column_number);
     value->SetString("sourceURL", info.source_url.spec());
     args.push_back(value.release());
-    web_ui_->CallJavascriptFunction("serviceworker.onErrorReported",
-                                    args.get());
+    web_ui_->CallJavascriptFunctionUnsafe("serviceworker.onErrorReported",
+                                          args.get());
   }
   void OnReportConsoleMessage(int64_t version_id,
                               int process_id,
                               int thread_id,
                               const ConsoleMessage& message) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     ScopedVector<const Value> args;
     args.push_back(new FundamentalValue(partition_id_));
     args.push_back(new StringValue(base::Int64ToString(version_id)));
     args.push_back(new FundamentalValue(process_id));
     args.push_back(new FundamentalValue(thread_id));
     std::unique_ptr<DictionaryValue> value(new DictionaryValue());
     value->SetInteger("sourceIdentifier", message.source_identifier);
     value->SetInteger("message_level", message.message_level);
     value->SetString("message", message.message);
     value->SetInteger("lineNumber", message.line_number);
     value->SetString("sourceURL", message.source_url.spec());
     args.push_back(value.release());
-    web_ui_->CallJavascriptFunction("serviceworker.onConsoleMessageReported",
-                                    args.get());
+    web_ui_->CallJavascriptFunctionUnsafe(
+        "serviceworker.onConsoleMessageReported", args.get());
   }
   void OnRegistrationStored(int64_t registration_id,
                             const GURL& pattern) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    web_ui_->CallJavascriptFunction("serviceworker.onRegistrationStored",
-                                    StringValue(pattern.spec()));
+    web_ui_->CallJavascriptFunctionUnsafe("serviceworker.onRegistrationStored",
+                                          StringValue(pattern.spec()));
   }
   void OnRegistrationDeleted(int64_t registration_id,
                              const GURL& pattern) override {
-    web_ui_->CallJavascriptFunction("serviceworker.onRegistrationDeleted",
-                                    StringValue(pattern.spec()));
+    web_ui_->CallJavascriptFunctionUnsafe("serviceworker.onRegistrationDeleted",
+                                          StringValue(pattern.spec()));
   }
   int partition_id() const { return partition_id_; }
 
  private:
   const int partition_id_;
   WebUI* const web_ui_;
 };
 
 ServiceWorkerInternalsUI::ServiceWorkerInternalsUI(WebUI* web_ui)
     : WebUIController(web_ui), next_partition_id_(0) {
@@ skipping 50 matching lines @@
       base::Bind(&ServiceWorkerInternalsUI::RemoveObserverFromStoragePartition,
                  base::Unretained(this));
   BrowserContext::ForEachStoragePartition(browser_context, remove_observer_cb);
 }
 
 void ServiceWorkerInternalsUI::GetOptions(const ListValue* args) {
   DictionaryValue options;
   options.SetBoolean("debug_on_start",
                      ServiceWorkerDevToolsManager::GetInstance()
                          ->debug_service_worker_on_start());
-  web_ui()->CallJavascriptFunction("serviceworker.onOptions", options);
+  web_ui()->CallJavascriptFunctionUnsafe("serviceworker.onOptions", options);
 }
 
 void ServiceWorkerInternalsUI::SetOption(const ListValue* args) {
   std::string option_name;
   bool option_boolean;
   if (!args->GetString(0, &option_name) || option_name != "debug_on_start" ||
       !args->GetBoolean(1, &option_boolean)) {
     return;
   }
   ServiceWorkerDevToolsManager::GetInstance()
@@ skipping 187 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
 
   // ServiceWorkerContextWrapper::UnregisterServiceWorker doesn't work here
   // because that reduces a status code to boolean.
   context->context()->UnregisterServiceWorker(scope, callback);
 }
 
 }  // namespace content