[Offline Pages] Removing client in storage manager.

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"
 #include "base/time/default_clock.h"
 #include "components/offline_pages/client_policy_controller.h"
 #include "components/offline_pages/offline_page_client_policy.h"
 #include "components/offline_pages/offline_page_item.h"
+#include "components/offline_pages/offline_page_model.h"
 
 namespace offline_pages {
 
 OfflinePageStorageManager::OfflinePageStorageManager(
-    Client* client,
+    OfflinePageModel* model,
     ClientPolicyController* policy_controller,
     ArchiveManager* archive_manager)
-    : client_(client),
+    : model_(model),
       policy_controller_(policy_controller),
       archive_manager_(archive_manager),
       clock_(new base::DefaultClock()),
       weak_ptr_factory_(this) {}
 
 OfflinePageStorageManager::~OfflinePageStorageManager() {}
 
 void OfflinePageStorageManager::ClearPagesIfNeeded(
     const ClearStorageCallback& callback) {
   if (IsInProgress())
@@ skipping 12 matching lines @@
 void OfflinePageStorageManager::OnGetStorageStatsDoneForClearingPages(
     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(
+  model_->GetAllPages(
       base::Bind(&OfflinePageStorageManager::OnGetAllPagesDoneForClearingPages,
                  weak_ptr_factory_.GetWeakPtr(), callback, stats));
 }
 
 void OfflinePageStorageManager::OnGetAllPagesDoneForClearingPages(
     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(
+  model_->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 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(
+  model_->DeletePagesByOfflineId(
       page_ids_to_remove,
       base::Bind(&OfflinePageStorageManager::OnOutdatedPagesCleared,
                  weak_ptr_factory_.GetWeakPtr(), callback, pages_expired,
                  expiration_succeeded));
 }
 
 void OfflinePageStorageManager::OnOutdatedPagesCleared(
     const ClearStorageCallback& callback,
     size_t pages_cleared,
     bool expiration_succeeded,
@@ skipping 108 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