Storage manager: Add site data size on the amount of browsing data.

chrome/browser/ui/webui/options/chromeos/storage_manager_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 <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"
+#include "chrome/browser/browsing_data/browsing_data_channel_id_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_cookie_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_database_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_file_system_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_flash_lso_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_indexed_db_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_local_storage_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_service_worker_helper.h"
 #include "chrome/browser/chromeos/arc/arc_auth_service.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/cryptohome/homedir_methods.h"
 #include "components/browsing_data/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 {
 
 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()
-    : browser_cache_size_(0),
-      browser_site_data_size_(0),
+    : browser_cache_size_(-1),
+      has_browser_cache_size_(false),
+      browser_site_data_size_(-1),
+      has_browser_site_data_size_(false),
       weak_ptr_factory_(this) {
 }
 
 StorageManagerHandler::~StorageManagerHandler() {
 }
 
 void StorageManagerHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
@@ skipping 186 matching lines @@
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void StorageManagerHandler::OnGetDriveCacheSize(int64_t size) {
   web_ui()->CallJavascriptFunctionUnsafe(
       "options.StorageManager.setDriveCacheSize",
       base::StringValue(ui::FormatBytes(size)));
 }
 
 void StorageManagerHandler::UpdateBrowsingDataSize() {
+  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));
 
-  // TODO(fukino): fetch the size of site data in browsing data.
+  // 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));
 }
 
 void StorageManagerHandler::OnGetBrowsingDataSize(bool is_site_data,
                                                   int64_t size) {
-  if (is_site_data)
+  if (is_site_data) {
+    has_browser_site_data_size_ = true;
     browser_site_data_size_ = size;
-  else
+  } else {
+    has_browser_cache_size_ = true;
     browser_cache_size_ = size;
-
-  web_ui()->CallJavascriptFunctionUnsafe(
-     "options.StorageManager.setBrowsingDataSize",
-     base::StringValue(ui::FormatBytes(static_cast<int64_t>(
-         browser_cache_size_ + browser_site_data_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);
+    }
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "options.StorageManager.setBrowsingDataSize",
+        base::StringValue(size_string));
+  }
 }
 
 void StorageManagerHandler::UpdateOtherUsersSize() {
   other_users_.clear();
   user_sizes_.clear();
   const user_manager::UserList& users =
       user_manager::UserManager::Get()->GetUsers();
   for (const 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()));
   }
 }
 
 void StorageManagerHandler::OnGetOtherUserSize(bool success, int64_t size) {
   user_sizes_.push_back(success ? size : -1);
   if (user_sizes_.size() == other_users_.size()) {
-    base::StringValue other_users_size(l10n_util::GetStringUTF16(
-        IDS_OPTIONS_SETTINGS_STORAGE_SIZE_UNKNOWN));
+    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) {
-      other_users_size = base::StringValue(ui::FormatBytes(
-          std::accumulate(user_sizes_.begin(), user_sizes_.end(), 0LL)));
+      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);
     }
     web_ui()->CallJavascriptFunctionUnsafe(
-       "options.StorageManager.setOtherUsersSize", other_users_size);
+        "options.StorageManager.setOtherUsersSize",
+        base::StringValue(size_string));
   }
 }
 
 void StorageManagerHandler::UpdateArcSize() {
   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");
   bool success = arc::ArcStorageManager::Get()->GetApplicationsSize(
       base::Bind(&StorageManagerHandler::OnGetArcSize,
                  base::Unretained(this)));
   if (!success) {
     // TODO(fukino): Retry updating arc size later if the arc bridge service is
     // not ready.
     web_ui()->CallJavascriptFunctionUnsafe(
         "options.StorageManager.setArcSize",
         base::StringValue(l10n_util::GetStringUTF16(
             IDS_OPTIONS_SETTINGS_STORAGE_SIZE_UNKNOWN)));
   }
 }
 
 void StorageManagerHandler::OnGetArcSize(bool succeeded,
                                          arc::mojom::ApplicationsSizePtr size) {
-  base::StringValue arc_size(l10n_util::GetStringUTF16(
-      IDS_OPTIONS_SETTINGS_STORAGE_SIZE_UNKNOWN));
+  base::string16 size_string;
   if (succeeded) {
     uint64_t total_bytes = size->total_code_bytes +
                            size->total_data_bytes +
                            size->total_cache_bytes;
-    arc_size = base::StringValue(ui::FormatBytes(total_bytes));
+    size_string = ui::FormatBytes(total_bytes);
+  } else {
+    size_string = l10n_util::GetStringUTF16(
+        IDS_OPTIONS_SETTINGS_STORAGE_SIZE_UNKNOWN);
   }
   web_ui()->CallJavascriptFunctionUnsafe("options.StorageManager.setArcSize",
-                                         arc_size);
+                                         base::StringValue(size_string));
 }
 
 void StorageManagerHandler::OnClearDriveCacheDone(bool success) {
   UpdateDriveCacheSize();
 }
 
 }  // namespace options
 }  // namespace chromeos