Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

chrome/browser/ui/webui/chromeos/drive_internals_ui.cc

 // Copyright (c) 2012 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/chromeos/drive_internals_ui.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 314 matching lines @@
   base::DictionaryValue about_resource;
   about_resource.SetDouble("account-quota-total",
                            parsed_about_resource->quota_bytes_total());
   about_resource.SetDouble("account-quota-used",
                            parsed_about_resource->quota_bytes_used_aggregate());
   about_resource.SetDouble("account-largest-changestamp-remote",
                            parsed_about_resource->largest_change_id());
   about_resource.SetString("root-resource-id",
                            parsed_about_resource->root_folder_id());
 
-  web_ui()->CallJavascriptFunction("updateAboutResource", about_resource);
+  web_ui()->CallJavascriptFunctionUnsafe("updateAboutResource", about_resource);
 }
 
 void DriveInternalsWebUIHandler::OnGetAppList(
     google_apis::DriveApiErrorCode status,
     std::unique_ptr<google_apis::AppList> parsed_app_list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (status != google_apis::HTTP_SUCCESS) {
     LOG(ERROR) << "Failed to get app list";
     return;
   }
   DCHECK(parsed_app_list);
 
   base::DictionaryValue app_list;
   app_list.SetString("etag", parsed_app_list->etag());
 
   base::ListValue* items = new base::ListValue();
   for (size_t i = 0; i < parsed_app_list->items().size(); ++i) {
     const google_apis::AppResource* app = parsed_app_list->items()[i];
     base::DictionaryValue* app_data = new base::DictionaryValue();
     app_data->SetString("name", app->name());
     app_data->SetString("application_id", app->application_id());
     app_data->SetString("object_type", app->object_type());
     app_data->SetBoolean("supports_create", app->supports_create());
 
     items->Append(app_data);
   }
   app_list.Set("items", items);
 
-  web_ui()->CallJavascriptFunction("updateAppList", app_list);
+  web_ui()->CallJavascriptFunctionUnsafe("updateAppList", app_list);
 }
 
 void DriveInternalsWebUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "pageLoaded",
       base::Bind(&DriveInternalsWebUIHandler::OnPageLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
   web_ui()->RegisterMessageCallback(
       "periodicUpdate",
       base::Bind(&DriveInternalsWebUIHandler::OnPeriodicUpdate,
@@ skipping 93 matching lines @@
 
   base::ListValue preferences;
   for (size_t i = 0; i < arraysize(kDriveRelatedPreferences); ++i) {
     const std::string key = kDriveRelatedPreferences[i];
     // As of now, all preferences are boolean.
     const std::string value =
         (pref_service->GetBoolean(key.c_str()) ? "true" : "false");
     AppendKeyValue(&preferences, key, value);
   }
 
-  web_ui()->CallJavascriptFunction("updateDriveRelatedPreferences",
-                                   preferences);
+  web_ui()->CallJavascriptFunctionUnsafe("updateDriveRelatedPreferences",
+                                         preferences);
 }
 
 void DriveInternalsWebUIHandler::UpdateConnectionStatusSection(
     drive::DriveServiceInterface* drive_service) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(drive_service);
 
   std::string status;
   switch (drive::util::GetDriveConnectionStatus(Profile::FromWebUI(web_ui()))) {
     case drive::util::DRIVE_DISCONNECTED_NOSERVICE:
@@ skipping 12 matching lines @@
       status = "connected";
       break;
   }
 
   base::DictionaryValue connection_status;
   connection_status.SetString("status", status);
   connection_status.SetBoolean("has-refresh-token",
                                drive_service->HasRefreshToken());
   connection_status.SetBoolean("has-access-token",
                                drive_service->HasAccessToken());
-  web_ui()->CallJavascriptFunction("updateConnectionStatus", connection_status);
+  web_ui()->CallJavascriptFunctionUnsafe("updateConnectionStatus",
+                                         connection_status);
 }
 
 void DriveInternalsWebUIHandler::UpdateAboutResourceSection(
     drive::DriveServiceInterface* drive_service) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(drive_service);
 
   drive_service->GetAboutResource(
       base::Bind(&DriveInternalsWebUIHandler::OnGetAboutResource,
                  weak_ptr_factory_.GetWeakPtr()));
@@ skipping 20 matching lines @@
 }
 
 void DriveInternalsWebUIHandler::OnGetFilesystemMetadataForLocal(
     const drive::FileSystemMetadata& metadata) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   base::DictionaryValue local_metadata;
   local_metadata.SetDouble("account-largest-changestamp-local",
                            metadata.largest_changestamp);
   local_metadata.SetBoolean("account-metadata-refreshing", metadata.refreshing);
-  web_ui()->CallJavascriptFunction("updateLocalMetadata", local_metadata);
+  web_ui()->CallJavascriptFunctionUnsafe("updateLocalMetadata", local_metadata);
 }
 
 void DriveInternalsWebUIHandler::ClearAccessToken(const base::ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   drive::DriveServiceInterface* drive_service = GetDriveService();
   if (drive_service)
     drive_service->ClearAccessToken();
 }
 
@@ skipping 15 matching lines @@
   if (integration_service) {
     integration_service->ClearCacheAndRemountFileSystem(
         base::Bind(&DriveInternalsWebUIHandler::ResetFinished,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void DriveInternalsWebUIHandler::ResetFinished(bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  web_ui()->CallJavascriptFunction("updateResetStatus",
-                                   base::FundamentalValue(success));
+  web_ui()->CallJavascriptFunctionUnsafe("updateResetStatus",
+                                         base::FundamentalValue(success));
 }
 
 void DriveInternalsWebUIHandler::ListFileEntries(const base::ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   UpdateFileSystemContentsSection();
 }
 
 void DriveInternalsWebUIHandler::UpdateDeltaUpdateStatusSection(
     drive::DebugInfoCollector* debug_info_collector) {
@@ skipping 21 matching lines @@
       "push-notification-enabled",
       drive_notification_manager->push_notification_enabled());
   delta_update_status.SetString(
       "last-update-check-time",
       google_apis::util::FormatTimeAsStringLocaltime(
           metadata.last_update_check_time));
   delta_update_status.SetString(
       "last-update-check-error",
       drive::FileErrorToString(metadata.last_update_check_error));
 
-  web_ui()->CallJavascriptFunction("updateDeltaUpdateStatus",
-                                   delta_update_status);
+  web_ui()->CallJavascriptFunctionUnsafe("updateDeltaUpdateStatus",
+                                         delta_update_status);
 }
 
 void DriveInternalsWebUIHandler::UpdateInFlightOperationsSection(
     drive::JobListInterface* job_list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(job_list);
 
   std::vector<drive::JobInfo> info_list = job_list->GetJobInfoList();
 
   base::ListValue in_flight_operations;
   for (size_t i = 0; i < info_list.size(); ++i) {
     const drive::JobInfo& info = info_list[i];
 
     base::DictionaryValue* dict = new base::DictionaryValue;
     dict->SetInteger("id", info.job_id);
     dict->SetString("type", drive::JobTypeToString(info.job_type));
     dict->SetString("file_path", info.file_path.AsUTF8Unsafe());
     dict->SetString("state", drive::JobStateToString(info.state));
     dict->SetDouble("progress_current", info.num_completed_bytes);
     dict->SetDouble("progress_total", info.num_total_bytes);
     in_flight_operations.Append(dict);
   }
-  web_ui()->CallJavascriptFunction("updateInFlightOperations",
-                                   in_flight_operations);
+  web_ui()->CallJavascriptFunctionUnsafe("updateInFlightOperations",
+                                         in_flight_operations);
 }
 
 void DriveInternalsWebUIHandler::UpdateGCacheContentsSection() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Start updating the GCache contents section.
   Profile* profile = Profile::FromWebUI(web_ui());
   const base::FilePath root_path = drive::util::GetCacheRootPath(profile);
   base::ListValue* gcache_contents = new base::ListValue;
   base::DictionaryValue* gcache_summary = new base::DictionaryValue;
@@ skipping 82 matching lines @@
 
     base::DictionaryValue* dict = new base::DictionaryValue;
     dict->SetString("key",
         google_apis::util::FormatTimeAsStringLocaltime(log[i].when));
     dict->SetString("value", "[" + severity + "] " + log[i].what);
     dict->SetString("class", "log-" + severity);
     list.Append(dict);
     last_sent_event_id_ = log[i].id;
   }
   if (!list.empty())
-    web_ui()->CallJavascriptFunction("updateEventLog", list);
+    web_ui()->CallJavascriptFunctionUnsafe("updateEventLog", list);
 }
 
 void DriveInternalsWebUIHandler::UpdatePathConfigurationsSection() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Profile* const profile = Profile::FromWebUI(web_ui());
 
   base::ListValue paths;
 
   AppendKeyValue(
       &paths, "Downloads",
       file_manager::util::GetDownloadsFolderForProfile(profile).AsUTF8Unsafe());
   AppendKeyValue(
       &paths, "Drive",
       drive::util::GetDriveMountPointPath(profile).AsUTF8Unsafe());
 
   const char* kPathPreferences[] = {
     prefs::kSelectFileLastDirectory,
     prefs::kSaveFileDefaultDirectory,
     prefs::kDownloadDefaultDirectory,
   };
   for (size_t i = 0; i < arraysize(kPathPreferences); ++i) {
     const char* const key = kPathPreferences[i];
     AppendKeyValue(&paths, key,
                    profile->GetPrefs()->GetFilePath(key).AsUTF8Unsafe());
   }
 
-  web_ui()->CallJavascriptFunction("updatePathConfigurations", paths);
+  web_ui()->CallJavascriptFunctionUnsafe("updatePathConfigurations", paths);
 }
 
 void DriveInternalsWebUIHandler::OnGetGCacheContents(
     base::ListValue* gcache_contents,
     base::DictionaryValue* gcache_summary) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(gcache_contents);
   DCHECK(gcache_summary);
 
-  web_ui()->CallJavascriptFunction("updateGCacheContents",
-                                   *gcache_contents,
-                                   *gcache_summary);
+  web_ui()->CallJavascriptFunctionUnsafe("updateGCacheContents",
+                                         *gcache_contents, *gcache_summary);
 }
 
 void DriveInternalsWebUIHandler::OnGetResourceEntryByPath(
     const base::FilePath& path,
     drive::FileError error,
     std::unique_ptr<drive::ResourceEntry> entry) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (error == drive::FILE_ERROR_OK) {
     DCHECK(entry.get());
     const base::StringValue value(FormatEntry(path, *entry) + "\n");
-    web_ui()->CallJavascriptFunction("updateFileSystemContents", value);
+    web_ui()->CallJavascriptFunctionUnsafe("updateFileSystemContents", value);
   }
 }
 
 void DriveInternalsWebUIHandler::OnReadDirectoryByPath(
     const base::FilePath& parent_path,
     drive::FileError error,
     std::unique_ptr<drive::ResourceEntryVector> entries) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (error == drive::FILE_ERROR_OK) {
@@ skipping 14 matching lines @@
             base::Bind(&DriveInternalsWebUIHandler::OnReadDirectoryByPath,
                        weak_ptr_factory_.GetWeakPtr(),
                        current_path));
       }
     }
 
     // There may be pending ReadDirectoryByPath() calls, but we can update
     // the page with what we have now. This results in progressive
     // updates, which is good for a large file system.
     const base::StringValue value(file_system_as_text);
-    web_ui()->CallJavascriptFunction("updateFileSystemContents", value);
+    web_ui()->CallJavascriptFunctionUnsafe("updateFileSystemContents", value);
   }
 }
 
 void DriveInternalsWebUIHandler::UpdateCacheEntry(
     const std::string& local_id,
     const drive::FileCacheEntry& cache_entry) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Convert |cache_entry| into a dictionary.
   base::DictionaryValue value;
   value.SetString("local_id", local_id);
   value.SetString("md5", cache_entry.md5());
   value.SetBoolean("is_present", cache_entry.is_present());
   value.SetBoolean("is_pinned", cache_entry.is_pinned());
   value.SetBoolean("is_dirty", cache_entry.is_dirty());
 
-  web_ui()->CallJavascriptFunction("updateCacheContents", value);
+  web_ui()->CallJavascriptFunctionUnsafe("updateCacheContents", value);
 }
 
 void DriveInternalsWebUIHandler::OnGetFreeDiskSpace(
     base::DictionaryValue* local_storage_summary) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(local_storage_summary);
 
-  web_ui()->CallJavascriptFunction(
-      "updateLocalStorageUsage", *local_storage_summary);
+  web_ui()->CallJavascriptFunctionUnsafe("updateLocalStorageUsage",
+                                         *local_storage_summary);
 }
 
 void DriveInternalsWebUIHandler::OnPeriodicUpdate(const base::ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   drive::DriveIntegrationService* integration_service =
       GetIntegrationService();
   // |integration_service| may be NULL in the guest/incognito mode.
   if (!integration_service)
     return;
@@ skipping 12 matching lines @@
       content::WebUIDataSource::Create(chrome::kChromeUIDriveInternalsHost);
   source->AddResourcePath("drive_internals.css", IDR_DRIVE_INTERNALS_CSS);
   source->AddResourcePath("drive_internals.js", IDR_DRIVE_INTERNALS_JS);
   source->SetDefaultResource(IDR_DRIVE_INTERNALS_HTML);
 
   Profile* profile = Profile::FromWebUI(web_ui);
   content::WebUIDataSource::Add(profile, source);
 }
 
 }  // namespace chromeos