[Offline pages] Moving disk size related calls to Archive Manager, reorganizing UMA

components/offline_pages/offline_page_model.cc

 // Copyright 2015 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 "components/offline_pages/offline_page_model.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 61 matching lines @@
     case ArchiverResult::ERROR_SECURITY_CERTIFICATE:
       result = SavePageResult::SECURITY_CERTIFICATE_ERROR;
       break;
     default:
       NOTREACHED();
       result = SavePageResult::CONTENT_UNAVAILABLE;
   }
   return result;
 }
 
+void ReportStorageUMAAfterSave(

[jianli, 2016/05/18 00:06:00]

ReportStorageHistogramsAfterSave

[fgorski, 2016/05/18 18:14:59]

Done.

+    const ArchiveManager::StorageSizes storage_sizes) {

[jianli, 2016/05/18 00:06:00]

nit: add &

[fgorski, 2016/05/18 18:14:59]

Done.

+  int mb = 1024 * 1024;

[jianli, 2016/05/18 00:06:00]

nit: const int or inline it

[fgorski, 2016/05/18 18:14:59]

Done.

+  int free_disk_space_mb = static_cast<int>(storage_sizes.free_disk_space / mb);
+  UMA_HISTOGRAM_CUSTOM_COUNTS("OfflinePages.SavePage.FreeSpaceMB",
+                              free_disk_space_mb, 1, 500000, 50);
+
+  int total_page_size_mb =
+      static_cast<int>(storage_sizes.total_archives_size / mb);
+  UMA_HISTOGRAM_COUNTS_10000("OfflinePages.TotalPageSize", total_page_size_mb);
+}
+
+void ReportStorageUMAAfterDelete(
+    const ArchiveManager::StorageSizes storage_sizes) {
+  int mb = 1024 * 1024;
+  int free_disk_space_mb = static_cast<int>(storage_sizes.free_disk_space / mb);
+  UMA_HISTOGRAM_CUSTOM_COUNTS("OfflinePages.DeletePage.FreeSpaceMB",
+                              free_disk_space_mb, 1, 500000, 50);
+
+  int total_page_size_mb =
+      static_cast<int>(storage_sizes.total_archives_size / mb);
+  UMA_HISTOGRAM_COUNTS_10000("OfflinePages.TotalPageSize", total_page_size_mb);
+
+  if (storage_sizes.free_disk_space > 0) {
+    int percentage_of_free = static_cast<int>(
+        1.0 * storage_sizes.total_archives_size /
+        (storage_sizes.total_archives_size + storage_sizes.free_disk_space) *
+        100);
+    UMA_HISTOGRAM_PERCENTAGE(
+        "OfflinePages.DeletePage.TotalPageSizeAsPercentageOfFreeSpace",
+        percentage_of_free);
+  }
+}
+
 }  // namespace
 
 // static
 bool OfflinePageModel::CanSavePage(const GURL& url) {
   return url.SchemeIsHTTPOrHTTPS();
 }
 
 // protected
 OfflinePageModel::OfflinePageModel()
     : is_loaded_(false), weak_ptr_factory_(this) {}
@@ skipping 360 matching lines @@
 }
 
 void OfflinePageModel::CheckForExternalFileDeletion() {
   DCHECK(is_loaded_);
 
   archive_manager_->GetAllArchives(
       base::Bind(&OfflinePageModel::ScanForMissingArchiveFiles,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void OfflinePageModel::RecordStorageHistograms(int64_t total_space_bytes,
-                                               int64_t free_space_bytes,
-                                               bool reporting_after_delete) {
-  // Total space taken by offline pages.
-  int64_t total_page_size = 0;
-  for (const auto& id_page_pair : offline_pages_) {
-    total_page_size += id_page_pair.second.file_size;
-  }
-
-  int total_page_size_mb = static_cast<int>(total_page_size / (1024 * 1024));
-  UMA_HISTOGRAM_COUNTS_10000("OfflinePages.TotalPageSize", total_page_size_mb);
-
-  // How much of the total space the offline pages take.
-  int total_page_size_percentage =
-      static_cast<int>(1.0 * total_page_size / total_space_bytes * 100);
-  UMA_HISTOGRAM_PERCENTAGE("OfflinePages.TotalPageSizePercentage",
-                           total_page_size_percentage);
-
-  // If the user is deleting the pages, perhaps they are running out of free
-  // space. Report the size before the operation, where a base for calculation
-  // of total free space includes space taken by offline pages.
-  if (reporting_after_delete && free_space_bytes > 0) {
-    int percentage_of_free = static_cast<int>(
-        1.0 * total_page_size / (total_page_size + free_space_bytes) * 100);
-    UMA_HISTOGRAM_PERCENTAGE(
-        "OfflinePages.DeletePage.TotalPageSizeAsPercentageOfFreeSpace",
-        percentage_of_free);
-  }
-}
-
 ClientPolicyController* OfflinePageModel::GetPolicyController() {
   return policy_controller_.get();
 }
 
 OfflinePageMetadataStore* OfflinePageModel::GetStoreForTesting() {
   return store_.get();
 }
 
 OfflinePageStorageManager* OfflinePageModel::GetStorageManager() {
   return storage_manager_.get();
@@ skipping 108 matching lines @@
   CheckForExternalFileDeletion();
 }
 
 void OfflinePageModel::InformSavePageDone(const SavePageCallback& callback,
                                           SavePageResult result,
                                           int64_t offline_id) {
   UMA_HISTOGRAM_ENUMERATION(
       "OfflinePages.SavePageResult",
       static_cast<int>(result),
       static_cast<int>(SavePageResult::RESULT_COUNT));
+  archive_manager_->GetStorageSizes(base::Bind(&ReportStorageUMAAfterSave));
   callback.Run(result, offline_id);
 }
 
 void OfflinePageModel::DeletePendingArchiver(OfflinePageArchiver* archiver) {
   pending_archivers_.erase(std::find(
       pending_archivers_.begin(), pending_archivers_.end(), archiver));
 }
 
 void OfflinePageModel::OnDeleteArchiveFilesDone(
     const std::vector<int64_t>& offline_ids,
@@ skipping 61 matching lines @@
                                      ? DeletePageResult::SUCCESS
                                      : DeletePageResult::STORE_FAILURE);
 }
 
 void OfflinePageModel::InformDeletePageDone(const DeletePageCallback& callback,
                                             DeletePageResult result) {
   UMA_HISTOGRAM_ENUMERATION(
       "OfflinePages.DeletePageResult",
       static_cast<int>(result),
       static_cast<int>(DeletePageResult::RESULT_COUNT));
+  archive_manager_->GetStorageSizes(base::Bind(&ReportStorageUMAAfterDelete));
   if (!callback.is_null())
     callback.Run(result);
 }
 
 void OfflinePageModel::ScanForMissingArchiveFiles(
     const std::set<base::FilePath>& archive_paths) {
   std::vector<int64_t> ids_of_pages_missing_archive_file;
   std::vector<std::pair<int64_t, ClientId>> offline_client_id_pairs;
   for (const auto& id_page_pair : offline_pages_) {
     if (archive_paths.count(id_page_pair.second.file_path) == 0UL) {
@@ skipping 80 matching lines @@
 void OfflinePageModel::RunWhenLoaded(const base::Closure& task) {
   if (!is_loaded_) {
     delayed_tasks_.push_back(task);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 }  // namespace offline_pages