Storage manager: Update storage usage periodically.

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>
 
@@ skipping 47 matching lines @@
 // 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_(-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) {
 }
 
 StorageManagerHandler::~StorageManagerHandler() {
 }
 
 void StorageManagerHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
@@ skipping 153 matching lines @@
     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);
 }
 
 void StorageManagerHandler::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()));
 }
 
 void StorageManagerHandler::OnGetDownloadsSize(int64_t size) {
+  updating_downloads_size_ = false;
   web_ui()->CallJavascriptFunctionUnsafe(
       "options.StorageManager.setDownloadsSize",
       base::StringValue(ui::FormatBytes(size)));
 }
 
 void StorageManagerHandler::UpdateDriveCacheSize() {
+  if (updating_drive_cache_size_)
+    return;
+  updating_drive_cache_size_ = true;
+
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(Profile::FromWebUI(web_ui()));
   file_system->CalculateCacheSize(
       base::Bind(&StorageManagerHandler::OnGetDriveCacheSize,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void StorageManagerHandler::OnGetDriveCacheSize(int64_t size) {
+  updating_drive_cache_size_ = false;
   web_ui()->CallJavascriptFunctionUnsafe(
       "options.StorageManager.setDriveCacheSize",
       base::StringValue(ui::FormatBytes(size)));
 }
 
 void StorageManagerHandler::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,
@@ skipping 36 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;
     web_ui()->CallJavascriptFunctionUnsafe(
         "options.StorageManager.setBrowsingDataSize",
         base::StringValue(size_string));
   }
 }
 
 void StorageManagerHandler::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 (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::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",
         base::StringValue(size_string));
   }
 }
 
 void StorageManagerHandler::UpdateArcSize() {
+  if (updating_arc_size_)
+    return;
+  updating_arc_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");
   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(

[fukino, 2016/07/08 10:28:37]

As we try to update the Android size every 5 seconds, we can keep it as
"Calculating..." until the arc bridge gets ready.

-        "options.StorageManager.setArcSize",
-        base::StringValue(l10n_util::GetStringUTF16(
-            IDS_OPTIONS_SETTINGS_STORAGE_SIZE_UNKNOWN)));
-  }
+  if (!success)
+    updating_arc_size_ = false;
 }
 
 void StorageManagerHandler::OnGetArcSize(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));
 }
 
 void StorageManagerHandler::OnClearDriveCacheDone(bool success) {
   UpdateDriveCacheSize();
 }
 
 }  // namespace options
 }  // namespace chromeos