[DO NOT COMMIT][Offline Pages] Moving Offline Page Cache to cache directory.

components/offline_pages/core/offline_page_model_impl.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/core/offline_page_model_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #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/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "components/offline_pages/core/archive_manager.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/offline_pages/core/client_policy_controller.h"
 #include "components/offline_pages/core/offline_page_item.h"
 #include "components/offline_pages/core/offline_page_model_query.h"
 #include "components/offline_pages/core/offline_page_storage_manager.h"
 #include "url/gurl.h"
 
-using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
-using ClearStorageCallback =
-    offline_pages::OfflinePageStorageManager::ClearStorageCallback;
-using ClearStorageResult =
-    offline_pages::OfflinePageStorageManager::ClearStorageResult;
+namespace offline_pages {
 
-namespace offline_pages {
+using ArchiverResult = OfflinePageArchiver::ArchiverResult;
+using ClearStorageCallback = OfflinePageStorageManager::ClearStorageCallback;
+using ClearStorageResult = OfflinePageStorageManager::ClearStorageResult;
+using LifetimeType = LifetimePolicy::LifetimeType;
 
 namespace {
 
 // The delay used to schedule the first clear storage request for storage
 // manager after the model is loaded.
 const base::TimeDelta kStorageManagerStartingDelay =
     base::TimeDelta::FromSeconds(20);
 
-int64_t GenerateOfflineId() {
-  return base::RandGenerator(std::numeric_limits<int64_t>::max()) + 1;
-}
-
 // The maximum histogram size for the metrics that measure time between views of
 // a given page.
 const base::TimeDelta kMaxOpenedPageHistogramBucket =
     base::TimeDelta::FromDays(90);
 
+// The const set representing all LifetimeTypes.
+const std::set<LifetimeType> kAllLifetimeTypes({LifetimeType::TEMPORARY,
+                                                LifetimeType::PERSISTENT});
+
+int64_t GenerateOfflineId() {
+  return base::RandGenerator(std::numeric_limits<int64_t>::max()) + 1;
+}
+
 SavePageResult ToSavePageResult(ArchiverResult archiver_result) {
   SavePageResult result;
   switch (archiver_result) {
     case ArchiverResult::SUCCESSFULLY_CREATED:
       result = SavePageResult::SUCCESS;
       break;
     case ArchiverResult::ERROR_DEVICE_FULL:
       result = SavePageResult::DEVICE_FULL;
       break;
     case ArchiverResult::ERROR_CONTENT_UNAVAILABLE:
@@ skipping 245 matching lines @@
 }
 
 }  // namespace
 
 // protected
 OfflinePageModelImpl::OfflinePageModelImpl()
     : OfflinePageModel(), is_loaded_(false), weak_ptr_factory_(this) {}
 
 OfflinePageModelImpl::OfflinePageModelImpl(
     std::unique_ptr<OfflinePageMetadataStore> store,
-    const base::FilePath& archives_dir,
+    const ArchiveDirectories& archive_dirs,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : store_(std::move(store)),
-      archives_dir_(archives_dir),
+      archive_dirs_(archive_dirs),
       is_loaded_(false),
       policy_controller_(new ClientPolicyController()),
-      archive_manager_(new ArchiveManager(archives_dir, task_runner)),
+      archive_manager_(new ArchiveManager(archive_dirs, task_runner)),
       testing_clock_(nullptr),
       weak_ptr_factory_(this) {
   archive_manager_->EnsureArchivesDirCreated(
       base::Bind(&OfflinePageModelImpl::OnEnsureArchivesDirCreatedDone,
                  weak_ptr_factory_.GetWeakPtr(), base::TimeTicks::Now()));
 }
 
 OfflinePageModelImpl::~OfflinePageModelImpl() {}
 
 void OfflinePageModelImpl::AddObserver(Observer* observer) {
@@ skipping 28 matching lines @@
   // If we already have an offline id, use it.  If not, generate one.
   int64_t offline_id = save_page_params.proposed_offline_id;
   if (offline_id == kInvalidOfflineId)
     offline_id = GenerateOfflineId();
 
   OfflinePageArchiver::CreateArchiveParams create_archive_params;
   // If the page is being saved in the background, we should try to remove the
   // popup overlay that obstructs viewing the normal content.
   create_archive_params.remove_popup_overlay = save_page_params.is_background;
   archiver->CreateArchive(
-      archives_dir_, create_archive_params,
+      GetArchiveDirectory(save_page_params.client_id.name_space),
+      create_archive_params,
       base::Bind(&OfflinePageModelImpl::OnCreateArchiveDone,
                  weak_ptr_factory_.GetWeakPtr(), save_page_params, offline_id,
                  GetCurrentTime(), callback));
   pending_archivers_.push_back(std::move(archiver));
 }
 
 void OfflinePageModelImpl::MarkPageAccessed(int64_t offline_id) {
   RunWhenLoaded(base::Bind(&OfflinePageModelImpl::MarkPageAccessedWhenLoadDone,
                            weak_ptr_factory_.GetWeakPtr(), offline_id));
 }
@@ skipping 469 matching lines @@
   // Clear storage.
   PostClearStorageIfNeededTask(true /* delayed */);
 }
 
 void OfflinePageModelImpl::InformSavePageDone(const SavePageCallback& callback,
                                               SavePageResult result,
                                               const ClientId& client_id,
                                               int64_t offline_id) {
   ReportSavePageResultHistogramAfterSave(client_id, result);
   archive_manager_->GetStorageStats(
-      base::Bind(&ReportStorageHistogramsAfterSave));
+      kAllLifetimeTypes, base::Bind(&ReportStorageHistogramsAfterSave));
   callback.Run(result, offline_id);
 }
 
 void OfflinePageModelImpl::DeleteExistingPagesWithSameURL(
     const OfflinePageItem& offline_page) {
   // Remove existing pages generated by the same policy and with same url.
   size_t pages_allowed =
       policy_controller_->GetPolicy(offline_page.client_id.name_space)
           .pages_allowed_per_url;
   if (pages_allowed == kUnlimitedPages)
@@ skipping 93 matching lines @@
   InformDeletePageDone(callback, delete_result);
 }
 
 void OfflinePageModelImpl::InformDeletePageDone(
     const DeletePageCallback& callback,
     DeletePageResult result) {
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.DeletePageResult",
                             static_cast<int>(result),
                             static_cast<int>(DeletePageResult::RESULT_COUNT));
   archive_manager_->GetStorageStats(
-      base::Bind(&ReportStorageHistogramsAfterDelete));
+      kAllLifetimeTypes, base::Bind(&ReportStorageHistogramsAfterDelete));
   if (!callback.is_null())
     callback.Run(result);
 }
 
 void OfflinePageModelImpl::CheckMetadataConsistencyForArchivePaths(
     const std::set<base::FilePath>& archive_paths) {
   DeletePagesMissingArchiveFile(archive_paths);
   DeleteOrphanedArchives(archive_paths);
 }
 
@@ skipping 91 matching lines @@
                                        weak_ptr_factory_.GetWeakPtr())),
       delay);
 }
 
 bool OfflinePageModelImpl::IsRemovedOnCacheReset(
     const OfflinePageItem& offline_page) const {
   return policy_controller_->IsRemovedOnCacheReset(
       offline_page.client_id.name_space);
 }
 
+const base::FilePath& OfflinePageModelImpl::GetArchiveDirectory(
+    const std::string& name_space) const {
+  return archive_dirs_.at(
+      policy_controller_->GetPolicy(name_space).lifetime_policy.lifetime_type);
+}
+
 void OfflinePageModelImpl::RunWhenLoaded(const base::Closure& task) {
   if (!is_loaded_) {
     delayed_tasks_.push_back(task);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 base::Time OfflinePageModelImpl::GetCurrentTime() const {
   return testing_clock_ ? testing_clock_->Now() : base::Time::Now();
 }
 
 }  // namespace offline_pages