Port storage manager to MD settings.

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/options/chromeos/storage_manager_handler.h"
+#include "chrome/browser/ui/webui/settings/chromeos/device_storage_handler.h"
 
 #include <algorithm>
 #include <numeric>
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_appcache_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_cache_storage_helper.h"
@@ skipping 15 matching lines @@
 #include "components/browsing_data/content/storage_partition_http_cache_data_remover.h"
 #include "components/drive/chromeos/file_system_interface.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/bytes_formatting.h"
 
 namespace chromeos {
-namespace options {
+namespace settings {
 namespace {
 
 void GetSizeStatOnBlockingPool(const base::FilePath& mount_path,
                                int64_t* total_size,
                                int64_t* available_size) {
   int64_t size = base::SysInfo::AmountOfTotalDiskSpace(mount_path);
   if (size >= 0)
     *total_size = size;
   size = base::SysInfo::AmountOfFreeDiskSpace(mount_path);
   if (size >= 0)
     *available_size = size;
 }
 
 // Threshold to show a message indicating space is critically low (512 MB).
 const int64_t kSpaceCriticallyLowBytes = 512 * 1024 * 1024;
 
 // Threshold to show a message indicating space is low (1 GB).
 const int64_t kSpaceLowBytes = 1 * 1024 * 1024 * 1024;
 
 }  // namespace
 
-StorageManagerHandler::StorageManagerHandler()
+StorageHandler::StorageHandler()
     : browser_cache_size_(-1),
       has_browser_cache_size_(false),
       browser_site_data_size_(-1),
       has_browser_site_data_size_(false),
       updating_downloads_size_(false),
       updating_drive_cache_size_(false),
       updating_browsing_data_size_(false),
-      updating_arc_size_(false),
-      updating_other_users_size_(false),
-      weak_ptr_factory_(this) {
+      updating_android_size_(false),
+      updating_other_users_size_(false) {
 }
 
-StorageManagerHandler::~StorageManagerHandler() {
+StorageHandler::~StorageHandler() {
 }
 
-void StorageManagerHandler::GetLocalizedValues(
-    base::DictionaryValue* localized_strings) {
-  DCHECK(localized_strings);
-
-  RegisterTitle(localized_strings, "storageManagerPage",
-                IDS_OPTIONS_SETTINGS_STORAGE_MANAGER_TAB_TITLE);
-  RegisterTitle(localized_strings, "storageClearDriveCachePage",
-                IDS_OPTIONS_SETTINGS_STORAGE_CLEAR_DRIVE_CACHE_TAB_TITLE);
-
-  localized_strings->SetString(
-      "storageItemLabelCapacity", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_ITEM_LABEL_CAPACITY));
-  localized_strings->SetString(
-      "storageItemLabelInUse", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_ITEM_LABEL_IN_USE));
-  localized_strings->SetString(
-      "storageItemLabelAvailable", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_ITEM_LABEL_AVAILABLE));
-  localized_strings->SetString(
-      "storageSubitemLabelDownloads", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SUBITEM_LABEL_DOWNLOADS));
-  localized_strings->SetString(
-      "storageSubitemLabelDriveCache", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SUBITEM_LABEL_DRIVE_CACHE));
-  localized_strings->SetString(
-      "storageSubitemLabelBrowsingData", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SUBITEM_LABEL_BROWSING_DATA));
-  localized_strings->SetString(
-      "storageSubitemLabelOtherUsers", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SUBITEM_LABEL_OTHER_USERS));
-  localized_strings->SetString(
-      "storageSubitemLabelArc", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SUBITEM_LABEL_ARC));
-  localized_strings->SetString(
-      "storageSizeCalculating", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SIZE_CALCULATING));
-  localized_strings->SetString(
-      "storageClearDriveCacheDialogTitle", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_CLEAR_DRIVE_CACHE_DIALOG_TITLE));
-  localized_strings->SetString(
-      "storageClearDriveCacheDescription", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_CLEAR_DRIVE_CACHE_DESCRIPTION));
-  localized_strings->SetString(
-      "storageDeleteAllButtonTitle", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_DELETE_ALL_BUTTON_TITLE));
-  localized_strings->SetString(
-      "storageLowMessageTitle", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SPACE_LOW_MESSAGE_TITLE));
-  localized_strings->SetString(
-      "storageLowMessageLine1", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SPACE_LOW_MESSAGE_LINE_1));
-  localized_strings->SetString(
-      "storageLowMessageLine2", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SPACE_LOW_MESSAGE_LINE_2));
-  localized_strings->SetString(
-      "storageCriticallyLowMessageTitle", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SPACE_CRITICALLY_LOW_MESSAGE_TITLE));
-  localized_strings->SetString(
-      "storageCriticallyLowMessageLine1", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SPACE_CRITICALLY_LOW_MESSAGE_LINE_1));
-  localized_strings->SetString(
-      "storageCriticallyLowMessageLine2", l10n_util::GetStringUTF16(
-          IDS_OPTIONS_SETTINGS_STORAGE_SPACE_CRITICALLY_LOW_MESSAGE_LINE_2));
-}
-
-void StorageManagerHandler::InitializePage() {
-  DCHECK(web_ui());
-}
-
-void StorageManagerHandler::RegisterMessages() {
+void StorageHandler::RegisterMessages() {
   DCHECK(web_ui());
 
   web_ui()->RegisterMessageCallback(
       "updateStorageInfo",
-      base::Bind(&StorageManagerHandler::HandleUpdateStorageInfo,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&StorageHandler::HandleUpdateStorageInfo,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "openDownloads",
-      base::Bind(&StorageManagerHandler::HandleOpenDownloads,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&StorageHandler::HandleOpenDownloads,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "openArcStorage",
-      base::Bind(&StorageManagerHandler::HandleOpenArcStorage,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&StorageHandler::HandleOpenArcStorage,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "clearDriveCache",
-      base::Bind(&StorageManagerHandler::HandleClearDriveCache,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&StorageHandler::HandleClearDriveCache,
+                 base::Unretained(this)));
 }
 
-void StorageManagerHandler::HandleUpdateStorageInfo(
-    const base::ListValue* unused_args) {
+void StorageHandler::HandleUpdateStorageInfo(const base::ListValue* args) {
+  AllowJavascript();
+
   UpdateSizeStat();
   UpdateDownloadsSize();
   UpdateDriveCacheSize();
   UpdateBrowsingDataSize();
   UpdateOtherUsersSize();
-  UpdateArcSize();
+  UpdateAndroidSize();
 }
 
-void StorageManagerHandler::HandleOpenDownloads(
+void StorageHandler::HandleOpenDownloads(
     const base::ListValue* unused_args) {
   Profile* const profile = Profile::FromWebUI(web_ui());
   const base::FilePath downloads_path =
       file_manager::util::GetDownloadsFolderForProfile(profile);
   platform_util::OpenItem(
        profile,
        downloads_path,
        platform_util::OPEN_FOLDER,
        platform_util::OpenOperationCallback());
 }
 
-void StorageManagerHandler::HandleOpenArcStorage(
+void StorageHandler::HandleOpenArcStorage(
     const base::ListValue* unused_args) {
   arc::ArcStorageManager::Get()->OpenPrivateVolumeSettings();
 }
 
-void StorageManagerHandler::HandleClearDriveCache(
+void StorageHandler::HandleClearDriveCache(
     const base::ListValue* unused_args) {
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(Profile::FromWebUI(web_ui()));
   file_system->FreeDiskSpaceIfNeededFor(
       std::numeric_limits<int64_t>::max(),  // Removes as much as possible.
-      base::Bind(&StorageManagerHandler::OnClearDriveCacheDone,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&StorageHandler::OnClearDriveCacheDone,
+                 base::Unretained(this)));
 }
 
-void StorageManagerHandler::UpdateSizeStat() {
+void StorageHandler::UpdateSizeStat() {
   Profile* const profile = Profile::FromWebUI(web_ui());
   const base::FilePath downloads_path =
      file_manager::util::GetDownloadsFolderForProfile(profile);
 
   int64_t* total_size = new int64_t(0);
   int64_t* available_size = new int64_t(0);
   content::BrowserThread::PostBlockingPoolTaskAndReply(
       FROM_HERE,
       base::Bind(&GetSizeStatOnBlockingPool,
                  downloads_path,
                  total_size,
                  available_size),
-      base::Bind(&StorageManagerHandler::OnGetSizeStat,
-                 weak_ptr_factory_.GetWeakPtr(),
+      base::Bind(&StorageHandler::OnGetSizeStat,
+                 base::Unretained(this),
                  base::Owned(total_size),
                  base::Owned(available_size)));
 }
 
-void StorageManagerHandler::OnGetSizeStat(int64_t* total_size,
-                                          int64_t* available_size) {
+void StorageHandler::OnGetSizeStat(int64_t* total_size,
+                                   int64_t* available_size) {
   int64_t used_size = *total_size - *available_size;
   base::DictionaryValue size_stat;
   size_stat.SetString("totalSize", ui::FormatBytes(*total_size));
   size_stat.SetString("availableSize", ui::FormatBytes(*available_size));
   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);
 
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "options.StorageManager.setSizeStat", size_stat);
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("storage-size-stat-changed"),
+                         size_stat);
 }
 
-void StorageManagerHandler::UpdateDownloadsSize() {
+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::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&base::ComputeDirectorySize, downloads_path),
-      base::Bind(&StorageManagerHandler::OnGetDownloadsSize,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&StorageHandler::OnGetDownloadsSize,
+                 base::Unretained(this)));
 }
 
-void StorageManagerHandler::OnGetDownloadsSize(int64_t size) {
+void StorageHandler::OnGetDownloadsSize(int64_t size) {
   updating_downloads_size_ = false;
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "options.StorageManager.setDownloadsSize",
-      base::StringValue(ui::FormatBytes(size)));
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("storage-downloads-size-changed"),
+                         base::StringValue(ui::FormatBytes(size)));
 }
 
-void StorageManagerHandler::UpdateDriveCacheSize() {
+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.
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "options.StorageManager.showDriveCacheItem");
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("storage-drive-enabled-changed"),
+                         base::FundamentalValue(true));
   updating_drive_cache_size_ = true;
   file_system->CalculateCacheSize(
-      base::Bind(&StorageManagerHandler::OnGetDriveCacheSize,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&StorageHandler::OnGetDriveCacheSize, base::Unretained(this)));
 }
 
-void StorageManagerHandler::OnGetDriveCacheSize(int64_t size) {
+void StorageHandler::OnGetDriveCacheSize(int64_t size) {
   updating_drive_cache_size_ = false;
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "options.StorageManager.setDriveCacheSize",
-      base::StringValue(ui::FormatBytes(size)));
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("storage-drive-cache-size-changed"),
+                         base::StringValue(ui::FormatBytes(size)));
 }
 
-void StorageManagerHandler::UpdateBrowsingDataSize() {
+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());
   // Fetch the size of http cache in browsing data.
   // StoragePartitionHttpCacheDataRemover deletes itself when it is done.
   browsing_data::StoragePartitionHttpCacheDataRemover::CreateForRange(
       content::BrowserContext::GetDefaultStoragePartition(profile),
       base::Time(),
       base::Time::Max())->Count(
-          base::Bind(&StorageManagerHandler::OnGetBrowsingDataSize,
-                     weak_ptr_factory_.GetWeakPtr(), false));
+          base::Bind(&StorageHandler::OnGetBrowsingDataSize,
+                     base::Unretained(this), false));
 
   // Fetch the size of site data in browsing data.
   if (!site_data_size_collector_.get()) {
     content::StoragePartition* storage_partition =
         content::BrowserContext::GetDefaultStoragePartition(profile);
     site_data_size_collector_.reset(new SiteDataSizeCollector(
         storage_partition->GetPath(),
         new BrowsingDataCookieHelper(profile->GetRequestContext()),
         new BrowsingDataDatabaseHelper(profile),
         new BrowsingDataLocalStorageHelper(profile),
         new BrowsingDataAppCacheHelper(profile),
         new BrowsingDataIndexedDBHelper(
             storage_partition->GetIndexedDBContext()),
         BrowsingDataFileSystemHelper::Create(
             storage_partition->GetFileSystemContext()),
         BrowsingDataChannelIDHelper::Create(profile->GetRequestContext()),
         new BrowsingDataServiceWorkerHelper(
             storage_partition->GetServiceWorkerContext()),
         new BrowsingDataCacheStorageHelper(
             storage_partition->GetCacheStorageContext()),
         BrowsingDataFlashLSOHelper::Create(profile)));
   }
   site_data_size_collector_->Fetch(
-      base::Bind(&StorageManagerHandler::OnGetBrowsingDataSize,
-                 weak_ptr_factory_.GetWeakPtr(), true));
+      base::Bind(&StorageHandler::OnGetBrowsingDataSize,
+                 base::Unretained(this), true));
 }
 
-void StorageManagerHandler::OnGetBrowsingDataSize(bool is_site_data,
-                                                  int64_t size) {
+void StorageHandler::OnGetBrowsingDataSize(bool is_site_data, int64_t size) {
   if (is_site_data) {
     has_browser_site_data_size_ = true;
     browser_site_data_size_ = size;
   } else {
     has_browser_cache_size_ = true;
     browser_cache_size_ = size;
   }
   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;
-    web_ui()->CallJavascriptFunctionUnsafe(
-        "options.StorageManager.setBrowsingDataSize",
+    CallJavascriptFunction(
+        "cr.webUIListenerCallback",
+        base::StringValue("storage-browsing-data-size-changed"),
         base::StringValue(size_string));
   }
 }
 
-void StorageManagerHandler::UpdateOtherUsersSize() {
+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(&StorageManagerHandler::OnGetOtherUserSize,
-                   weak_ptr_factory_.GetWeakPtr()));
+        base::Bind(&StorageHandler::OnGetOtherUserSize,
+                   base::Unretained(this)));
   }
   // We should show "0 B" if there is no other user.
   if (other_users_.empty()) {
     updating_other_users_size_ = false;
-    web_ui()->CallJavascriptFunctionUnsafe(
-        "options.StorageManager.setOtherUsersSize",
+    CallJavascriptFunction(
+        "cr.webUIListenerCallback",
+        base::StringValue("storage-other-users-size-changed"),
         base::StringValue(ui::FormatBytes(0)));
   }
 }
 
-void StorageManagerHandler::OnGetOtherUserSize(bool success, int64_t size) {
+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;
-    web_ui()->CallJavascriptFunctionUnsafe(
-        "options.StorageManager.setOtherUsersSize",
+    CallJavascriptFunction(
+        "cr.webUIListenerCallback",
+        base::StringValue("storage-other-users-size-changed"),
         base::StringValue(size_string));
   }
 }
 
-void StorageManagerHandler::UpdateArcSize() {
-  if (updating_arc_size_)
+void StorageHandler::UpdateAndroidSize() {
+  if (updating_android_size_)
     return;
-  updating_arc_size_ = true;
+  updating_android_size_ = true;
 
   Profile* const profile = Profile::FromWebUI(web_ui());
   if (!arc::ArcAuthService::IsAllowedForProfile(profile) ||
       arc::ArcAuthService::IsOptInVerificationDisabled() ||
       !arc::ArcAuthService::Get()->IsArcEnabled()) {
     return;
   }
 
   // Shows the item "Android apps and cache" and start calculating size.
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "options.StorageManager.showArcItem");
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("storage-android-enabled-changed"),
+                         base::FundamentalValue(true));
   bool success = arc::ArcStorageManager::Get()->GetApplicationsSize(
-      base::Bind(&StorageManagerHandler::OnGetArcSize,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&StorageHandler::OnGetAndroidSize,
+                 base::Unretained(this)));
   if (!success)
-    updating_arc_size_ = false;
+    updating_android_size_ = false;
 }
 
-void StorageManagerHandler::OnGetArcSize(bool succeeded,
-                                         arc::mojom::ApplicationsSizePtr size) {
+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_arc_size_ = false;
-  web_ui()->CallJavascriptFunctionUnsafe("options.StorageManager.setArcSize",
-                                         base::StringValue(size_string));
+  updating_android_size_ = false;
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("storage-android-size-changed"),
+                         base::StringValue(size_string));
 }
 
-void StorageManagerHandler::OnClearDriveCacheDone(bool success) {
+void StorageHandler::OnClearDriveCacheDone(bool success) {
   UpdateDriveCacheSize();
 }
 
-}  // namespace options
+}  // namespace settings
 }  // namespace chromeos