MD Settings: Use FireWebUIListener() helper wherever possible.

chrome/browser/ui/webui/settings/chromeos/device_storage_handler.cc

 // Copyright 2016 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/settings/chromeos/device_storage_handler.h"
 
 #include <algorithm>
 #include <numeric>
 #include <string>
 
@@ skipping 148 matching lines @@
   size_stat.SetString("usedSize", ui::FormatBytes(used_size));
   size_stat.SetDouble("usedRatio",
                       static_cast<double>(used_size) / *total_size);
   int storage_space_state = STORAGE_SPACE_NORMAL;
   if (*available_size < kSpaceCriticallyLowBytes)
     storage_space_state = STORAGE_SPACE_CRITICALLY_LOW;
   else if (*available_size < kSpaceLowBytes)
     storage_space_state = STORAGE_SPACE_LOW;
   size_stat.SetInteger("spaceState", storage_space_state);
 
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("storage-size-stat-changed"), size_stat);
+  FireWebUIListener("storage-size-stat-changed", size_stat);
 }
 
 void StorageHandler::UpdateDownloadsSize() {
   if (updating_downloads_size_)
     return;
   updating_downloads_size_ = true;
 
   Profile* const profile = Profile::FromWebUI(web_ui());
   const base::FilePath downloads_path =
       file_manager::util::GetDownloadsFolderForProfile(profile);
 
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, {base::MayBlock(), base::TaskPriority::BACKGROUND},
       base::Bind(&base::ComputeDirectorySize, downloads_path),
       base::Bind(&StorageHandler::OnGetDownloadsSize,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void StorageHandler::OnGetDownloadsSize(int64_t size) {
   updating_downloads_size_ = false;
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("storage-downloads-size-changed"),
-                         base::Value(ui::FormatBytes(size)));
+  FireWebUIListener("storage-downloads-size-changed",
+                    base::Value(ui::FormatBytes(size)));
 }
 
 void StorageHandler::UpdateDriveCacheSize() {
   if (updating_drive_cache_size_)
     return;
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(Profile::FromWebUI(web_ui()));
   if (!file_system)
     return;
 
   // Shows the item "Offline cache" and start calculating size.
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("storage-drive-enabled-changed"),
-                         base::Value(true));
+  FireWebUIListener("storage-drive-enabled-changed", base::Value(true));
   updating_drive_cache_size_ = true;
   file_system->CalculateCacheSize(base::Bind(
       &StorageHandler::OnGetDriveCacheSize, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void StorageHandler::OnGetDriveCacheSize(int64_t size) {
   updating_drive_cache_size_ = false;
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("storage-drive-cache-size-changed"),
-                         base::Value(ui::FormatBytes(size)),
-                         base::Value(size > 0));
+  FireWebUIListener("storage-drive-cache-size-changed",
+                    base::Value(ui::FormatBytes(size)), base::Value(size > 0));
 }
 
 void StorageHandler::UpdateBrowsingDataSize() {
   if (updating_browsing_data_size_)
     return;
   updating_browsing_data_size_ = true;
 
   has_browser_cache_size_ = false;
   has_browser_site_data_size_ = false;
   Profile* const profile = Profile::FromWebUI(web_ui());
@@ skipping 47 matching lines @@
   if (has_browser_cache_size_ && has_browser_site_data_size_) {
     base::string16 size_string;
     if (browser_cache_size_ >= 0 && browser_site_data_size_ >= 0) {
       size_string = ui::FormatBytes(
           browser_site_data_size_ + browser_cache_size_);
     } else {
       size_string = l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_STORAGE_SIZE_UNKNOWN);
     }
     updating_browsing_data_size_ = false;
-    CallJavascriptFunction("cr.webUIListenerCallback",
-                           base::Value("storage-browsing-data-size-changed"),
-                           base::Value(size_string));
+    FireWebUIListener("storage-browsing-data-size-changed",
+                      base::Value(size_string));
   }
 }
 
 void StorageHandler::UpdateOtherUsersSize() {
   if (updating_other_users_size_)
     return;
   updating_other_users_size_ = true;
 
   other_users_.clear();
   user_sizes_.clear();
   const user_manager::UserList& users =
       user_manager::UserManager::Get()->GetUsers();
   for (auto* user : users) {
     if (user->is_active())
       continue;
     other_users_.push_back(user);
     cryptohome::HomedirMethods::GetInstance()->GetAccountDiskUsage(
         cryptohome::Identification(user->GetAccountId()),
         base::Bind(&StorageHandler::OnGetOtherUserSize,
                    weak_ptr_factory_.GetWeakPtr()));
   }
   // We should show "0 B" if there is no other user.
   if (other_users_.empty()) {
     updating_other_users_size_ = false;
-    CallJavascriptFunction("cr.webUIListenerCallback",
-                           base::Value("storage-other-users-size-changed"),
-                           base::Value(ui::FormatBytes(0)));
+    FireWebUIListener("storage-other-users-size-changed",
+                      base::Value(ui::FormatBytes(0)));
   }
 }
 
 void StorageHandler::OnGetOtherUserSize(bool success, int64_t size) {
   user_sizes_.push_back(success ? size : -1);
   if (user_sizes_.size() == other_users_.size()) {
     base::string16 size_string;
     // If all the requests succeed, shows the total bytes in the UI.
     if (std::count(user_sizes_.begin(), user_sizes_.end(), -1) == 0) {
       size_string = ui::FormatBytes(
           std::accumulate(user_sizes_.begin(), user_sizes_.end(), 0LL));
     } else {
       size_string = l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_STORAGE_SIZE_UNKNOWN);
     }
     updating_other_users_size_ = false;
-    CallJavascriptFunction("cr.webUIListenerCallback",
-                           base::Value("storage-other-users-size-changed"),
-                           base::Value(size_string));
+    FireWebUIListener("storage-other-users-size-changed",
+                      base::Value(size_string));
   }
 }
 
 void StorageHandler::UpdateAndroidSize() {
   if (updating_android_size_)
     return;
   updating_android_size_ = true;
 
   Profile* const profile = Profile::FromWebUI(web_ui());
   if (!arc::IsArcPlayStoreEnabledForProfile(profile) ||
       arc::IsArcOptInVerificationDisabled()) {
     return;
   }
 
   // Shows the item "Android apps and cache" and start calculating size.
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("storage-android-enabled-changed"),
-                         base::Value(true));
+  FireWebUIListener("storage-android-enabled-changed", base::Value(true));
   bool success = arc::ArcStorageManager::Get()->GetApplicationsSize(base::Bind(
       &StorageHandler::OnGetAndroidSize, weak_ptr_factory_.GetWeakPtr()));
   if (!success)
     updating_android_size_ = false;
 }
 
 void StorageHandler::OnGetAndroidSize(bool succeeded,
                                       arc::mojom::ApplicationsSizePtr size) {
   base::string16 size_string;
   if (succeeded) {
     uint64_t total_bytes = size->total_code_bytes +
                            size->total_data_bytes +
                            size->total_cache_bytes;
     size_string = ui::FormatBytes(total_bytes);
   } else {
     size_string = l10n_util::GetStringUTF16(
         IDS_OPTIONS_SETTINGS_STORAGE_SIZE_UNKNOWN);
   }
   updating_android_size_ = false;
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("storage-android-size-changed"),
-                         base::Value(size_string));
+  FireWebUIListener("storage-android-size-changed", base::Value(size_string));
 }
 
 void StorageHandler::OnClearDriveCacheDone(bool success) {
   UpdateDriveCacheSize();
 }
 
 }  // namespace settings
 }  // namespace chromeos