Using separate directories based on LifetimeType.

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/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "components/offline_pages/client_policy_controller.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/proto/offline_pages.pb.h"
 #include "url/gurl.h"
 
 using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
 using SavePageResult = offline_pages::OfflinePageModel::SavePageResult;
+using ArchiveDirs = offline_pages::OfflinePageModel::ArchiveDirs;
 
 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 52 matching lines @@
   DCHECK(ids_of_pages_missing_archive_file);
 
   for (const auto& id_path : id_path_pairs) {
     if (!base::PathExists(id_path.second) ||
         base::DirectoryExists(id_path.second)) {
       ids_of_pages_missing_archive_file->push_back(id_path.first);
     }
   }
 }
 
-void EnsureArchivesDirCreated(const base::FilePath& archives_dir) {
-  CHECK(base::CreateDirectory(archives_dir));
+void EnsureArchivesDirCreated(const ArchiveDirs& archive_dirs) {
+  for (const auto& iter : archive_dirs) {
+    CHECK(base::CreateDirectory(iter.second));
+  }
 }
 
 }  // namespace
 
 // static
 bool OfflinePageModel::CanSavePage(const GURL& url) {
   return url.SchemeIsHTTPOrHTTPS();
 }
 
 OfflinePageModel::OfflinePageModel(
     std::unique_ptr<OfflinePageMetadataStore> store,
-    const base::FilePath& archives_dir,
+    const ArchiveDirs& archive_dirs,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : store_(std::move(store)),
-      archives_dir_(archives_dir),
+      archive_dirs_(archive_dirs),
       is_loaded_(false),
       task_runner_(task_runner),
       weak_ptr_factory_(this) {
   task_runner_->PostTaskAndReply(
-      FROM_HERE, base::Bind(EnsureArchivesDirCreated, archives_dir_),
+      FROM_HERE, base::Bind(EnsureArchivesDirCreated, archive_dirs_),
       base::Bind(&OfflinePageModel::OnEnsureArchivesDirCreatedDone,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 OfflinePageModel::~OfflinePageModel() {
 }
 
 void OfflinePageModel::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 13 matching lines @@
   if (!CanSavePage(url)) {
     InformSavePageDone(callback, SavePageResult::SKIPPED, kInvalidOfflineId);
     return;
   }
 
   DCHECK(archiver.get());
 
   int64_t offline_id = GenerateOfflineId();
 
   archiver->CreateArchive(
-      archives_dir_,
+      GetArchivePath(client_id),
       offline_id,
       base::Bind(&OfflinePageModel::OnCreateArchiveDone,
                  weak_ptr_factory_.GetWeakPtr(), url, offline_id,
                  client_id, base::Time::Now(), callback));
   pending_archivers_.push_back(std::move(archiver));
 }
 
 void OfflinePageModel::MarkPageAccessed(int64_t offline_id) {
   DCHECK(is_loaded_);
   auto iter = offline_pages_.find(offline_id);
@@ skipping 544 matching lines @@
     const std::vector<OfflinePageItem>& offline_pages) {
   offline_pages_.clear();
   for (const auto& offline_page : offline_pages)
     offline_pages_[offline_page.offline_id] = offline_page;
 }
 
 int64_t OfflinePageModel::GenerateOfflineId() {
   return base::RandGenerator(std::numeric_limits<int64_t>::max()) + 1;
 }
 
+const base::FilePath& OfflinePageModel::GetArchivePath(
+    const ClientId& client_id) {
+  OfflinePageClientPolicy policy =
+      ClientPolicyController::GetInstance().GetPolicy(client_id.name_space);
+  return archive_dirs_.at(policy.lifetime_policy.type);
+}
+
 void OfflinePageModel::RunWhenLoaded(const base::Closure& task) {
   if (!is_loaded_) {
     delayed_tasks_.push_back(task);
     return;
   }
 
   task_runner_->PostTask(FROM_HERE, task);
 }
 
 }  // namespace offline_pages