[Offline Pages] Linking storage manager and model with UMAs.

components/offline_pages/offline_page_storage_manager.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 "components/offline_pages/offline_page_storage_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/time/clock.h"
@@ skipping 10 matching lines @@
     ArchiveManager* archive_manager)
     : client_(client),
       policy_controller_(policy_controller),
       archive_manager_(archive_manager),
       clock_(new base::DefaultClock()),
       weak_ptr_factory_(this) {}
 
 OfflinePageStorageManager::~OfflinePageStorageManager() {}
 
 void OfflinePageStorageManager::ClearPagesIfNeeded(
-    const ClearPagesCallback& callback) {
+    const ClearStorageCallback& callback) {
   if (IsInProgress())
     return;
   clear_time_ = clock_->Now();
   archive_manager_->GetStorageStats(base::Bind(
       &OfflinePageStorageManager::OnGetStorageStatsDoneForClearingPages,
       weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void OfflinePageStorageManager::SetClockForTesting(
     std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }
 
 void OfflinePageStorageManager::OnGetStorageStatsDoneForClearingPages(
-    const ClearPagesCallback& callback,
+    const ClearStorageCallback& callback,
     const ArchiveManager::StorageStats& stats) {
   DCHECK(IsInProgress());
   ClearMode mode = ShouldClearPages(stats);
   if (mode == ClearMode::NOT_NEEDED) {
     last_clear_time_ = clear_time_;
     callback.Run(0, ClearStorageResult::UNNECESSARY);
     return;
   }
   client_->GetAllPages(
       base::Bind(&OfflinePageStorageManager::OnGetAllPagesDoneForClearingPages,
                  weak_ptr_factory_.GetWeakPtr(), callback, stats));
 }
 
 void OfflinePageStorageManager::OnGetAllPagesDoneForClearingPages(
-    const ClearPagesCallback& callback,
+    const ClearStorageCallback& callback,
     const ArchiveManager::StorageStats& stats,
     const MultipleOfflinePageItemResult& pages) {
   std::vector<int64_t> page_ids_to_expire;
   std::vector<int64_t> page_ids_to_remove;
   GetPageIdsToClear(pages, stats, &page_ids_to_expire, &page_ids_to_remove);
   client_->ExpirePages(
       page_ids_to_expire, clear_time_,
       base::Bind(&OfflinePageStorageManager::OnPagesExpired,
                  weak_ptr_factory_.GetWeakPtr(), callback,
                  page_ids_to_expire.size(), page_ids_to_remove));
 }
 
 void OfflinePageStorageManager::OnPagesExpired(
-    const ClearPagesCallback& callback,
+    const ClearStorageCallback& callback,
     size_t pages_expired,
     const std::vector<int64_t>& page_ids_to_remove,
     bool expiration_succeeded) {
   // We want to delete the outdated page records regardless the expiration
   // succeeded or not.
   client_->DeletePagesByOfflineId(
       page_ids_to_remove,
       base::Bind(&OfflinePageStorageManager::OnOutdatedPagesCleared,
                  weak_ptr_factory_.GetWeakPtr(), callback, pages_expired,
                  expiration_succeeded));
 }
 
 void OfflinePageStorageManager::OnOutdatedPagesCleared(
-    const ClearPagesCallback& callback,
+    const ClearStorageCallback& callback,
     size_t pages_cleared,
     bool expiration_succeeded,
     DeletePageResult result) {
   ClearStorageResult clear_result = ClearStorageResult::SUCCESS;
   if (!expiration_succeeded) {
     clear_result = ClearStorageResult::EXPIRE_FAILURE;
     if (result != DeletePageResult::SUCCESS)
       clear_result = ClearStorageResult::EXPIRE_AND_DELETE_FAILURES;
   } else if (result != DeletePageResult::SUCCESS) {
     clear_result = ClearStorageResult::DELETE_FAILURE;
@@ skipping 100 matching lines @@
   const LifetimePolicy& policy =
       policy_controller_->GetPolicy(page.client_id.name_space).lifetime_policy;
   return clear_time_ - page.last_access_time >= policy.expiration_period;
 }
 
 bool OfflinePageStorageManager::IsInProgress() const {
   return clear_time_ > last_clear_time_;
 }
 
 }  // namespace offline_pages