[Useless] Hooking up storage manager in page model.

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"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/optional.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/offline_pages/archive_manager.h"
 #include "components/offline_pages/client_policy_controller.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_storage_manager.h"
 #include "components/offline_pages/proto/offline_pages.pb.h"
 #include "url/gurl.h"
 
 using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
+using ClearPagesCallback =
+    offline_pages::OfflinePageStorageManager::ClearPagesCallback;
 
 namespace offline_pages {
 
 namespace {
 
 // This enum is used in an UMA histogram. Hence the entries here shouldn't
 // be deleted or re-ordered and new ones should be added to the end.
 enum ClearAllStatus {
   CLEAR_ALL_SUCCEEDED,
   STORE_RESET_FAILED,
@@ skipping 462 matching lines @@
 }
 
 void OfflinePageModel::CheckForExternalFileDeletion() {
   DCHECK(is_loaded_);
 
   archive_manager_->GetAllArchives(
       base::Bind(&OfflinePageModel::ScanForMissingArchiveFiles,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+void OfflinePageModel::ExpirePages(const ClearPagesCallback& callback) {
+  storage_manager_->ClearPagesIfNeeded(callback);
+}
+
 ClientPolicyController* OfflinePageModel::GetPolicyController() {
   return policy_controller_.get();
 }
 
 OfflinePageMetadataStore* OfflinePageModel::GetStoreForTesting() {
   return store_.get();
 }
 
 OfflinePageStorageManager* OfflinePageModel::GetStorageManager() {
   return storage_manager_.get();
@@ skipping 100 matching lines @@
 
   // Create Storage Manager.
   storage_manager_.reset(new OfflinePageStorageManager(
       this, GetPolicyController(), archive_manager_.get()));
 
   // Run all the delayed tasks.
   for (const auto& delayed_task : delayed_tasks_)
     delayed_task.Run();
   delayed_tasks_.clear();
 
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&OfflinePageModel::ExpirePages, weak_ptr_factory_.GetWeakPtr(),
+                 base::Bind(&OfflinePageModel::OnExpiredPagesCleared,
+                            weak_ptr_factory_.GetWeakPtr())),
+      base::TimeDelta::FromSeconds(20));
+
   FOR_EACH_OBSERVER(Observer, observers_, OfflinePageModelLoaded(this));
 
   CheckForExternalFileDeletion();
 }
 
 void OfflinePageModel::InformSavePageDone(const SavePageCallback& callback,
                                           SavePageResult result,
                                           const ClientId& client_id,
                                           int64_t offline_id) {
   UMA_HISTOGRAM_ENUMERATION(
       AddHistogramSuffix(client_id, "OfflinePages.SavePageResult").c_str(),
       static_cast<int>(result),
       static_cast<int>(SavePageResult::RESULT_COUNT));
   archive_manager_->GetStorageStats(
       base::Bind(&ReportStorageHistogramsAfterSave));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&OfflinePageModel::ExpirePages, weak_ptr_factory_.GetWeakPtr(),
+                 base::Bind(&OfflinePageModel::OnExpiredPagesCleared,
+                            weak_ptr_factory_.GetWeakPtr())));
   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 156 matching lines @@
   callback.Run();
 }
 
 void OfflinePageModel::CacheLoadedData(
     const std::vector<OfflinePageItem>& offline_pages) {
   offline_pages_.clear();
   for (const auto& offline_page : offline_pages)
     offline_pages_[offline_page.offline_id] = offline_page;
 }
 
+void OfflinePageModel::OnExpiredPagesCleared(
+    const int expired_page_count,
+    OfflinePageStorageManager::ClearStorageResult result) {
+  // TODO(romax) Add something here.
+}
+
+// static
 int64_t OfflinePageModel::GenerateOfflineId() {
   return base::RandGenerator(std::numeric_limits<int64_t>::max()) + 1;
 }
 
 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