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

components/offline_pages/core/archive_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/core/archive_manager.h"
+
+#include <set>
+#include <vector>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "components/offline_pages/core/archive_manager.h"
 
 namespace offline_pages {
 
+using LifetimeType = LifetimePolicy::LifetimeType;
+
 namespace {
 
 using StorageStatsCallback =
     base::Callback<void(const ArchiveManager::StorageStats& storage_stats)>;
 
-void EnsureArchivesDirCreatedImpl(const base::FilePath& archives_dir) {
-  CHECK(base::CreateDirectory(archives_dir));
+void EnsureArchivesDirCreatedImpl(const ArchiveDirectories& archive_dirs) {
+  for (const auto& archive_dir : archive_dirs) {
+    CHECK(base::CreateDirectory(archive_dir.second));
+  }
 }
 
 void ExistsArchiveImpl(const base::FilePath& file_path,
                        scoped_refptr<base::SequencedTaskRunner> task_runner,
                        const base::Callback<void(bool)>& callback) {
   task_runner->PostTask(FROM_HERE,
                         base::Bind(callback, base::PathExists(file_path)));
 }
 
 void DeleteArchivesImpl(const std::vector<base::FilePath>& file_paths,
                         scoped_refptr<base::SequencedTaskRunner> task_runner,
                         const base::Callback<void(bool)>& callback) {
   bool result = false;
   for (const auto& file_path : file_paths) {
     // Make sure delete happens on the left of || so that it is always executed.
     result = base::DeleteFile(file_path, false) || result;
   }
   task_runner->PostTask(FROM_HERE, base::Bind(callback, result));
 }
 
 void GetAllArchivesImpl(
-    const base::FilePath& archive_dir,
+    const std::vector<base::FilePath>& archive_dirs,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const base::Callback<void(const std::set<base::FilePath>&)>& callback) {
   std::set<base::FilePath> archive_paths;
-  base::FileEnumerator file_enumerator(archive_dir, false,
-                                       base::FileEnumerator::FILES);
-  for (base::FilePath archive_path = file_enumerator.Next();
-       !archive_path.empty(); archive_path = file_enumerator.Next()) {
-    archive_paths.insert(archive_path);
+  // Iterate through all the archive directories.
+  for (const auto& archive_dir : archive_dirs) {
+    base::FileEnumerator file_enumerator(archive_dir, false,
+                                         base::FileEnumerator::FILES);
+    for (base::FilePath archive_path = file_enumerator.Next();
+         !archive_path.empty(); archive_path = file_enumerator.Next()) {
+      archive_paths.insert(archive_path);
+    }
   }
   task_runner->PostTask(FROM_HERE, base::Bind(callback, archive_paths));
 }
 
-void GetStorageStatsImpl(const base::FilePath& archive_dir,
+void GetStorageStatsImpl(const std::vector<base::FilePath>& archive_dirs,
                          scoped_refptr<base::SequencedTaskRunner> task_runner,
                          const StorageStatsCallback& callback) {
   ArchiveManager::StorageStats storage_stats;
-  storage_stats.free_disk_space =
-      base::SysInfo::AmountOfFreeDiskSpace(archive_dir);
-  storage_stats.total_archives_size = base::ComputeDirectorySize(archive_dir);
+  storage_stats.free_disk_space = 0;
+  storage_stats.total_archives_size = 0;
+  // Since currently both types of pages are still saved on the same disk, we
+  // should divide the free disk space by the number of places we save pages.
+  for (const auto& archive_dir : archive_dirs) {
+    storage_stats.free_disk_space +=
+        base::SysInfo::AmountOfFreeDiskSpace(archive_dir);
+    storage_stats.total_archives_size +=
+        base::ComputeDirectorySize(archive_dir);
+  }
+  storage_stats.free_disk_space /= archive_dirs.size();
   task_runner->PostTask(FROM_HERE, base::Bind(callback, storage_stats));
 }
 
 }  // namespace
 
 // protected and used for testing.
 ArchiveManager::ArchiveManager() {}
 
 ArchiveManager::ArchiveManager(
-    const base::FilePath& archives_dir,
+    const ArchiveDirectories& archive_dirs,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
-    : archives_dir_(archives_dir), task_runner_(task_runner) {}
+    : archive_dirs_(archive_dirs), task_runner_(task_runner) {}
 
 ArchiveManager::~ArchiveManager() {}
 
 void ArchiveManager::EnsureArchivesDirCreated(const base::Closure& callback) {
   task_runner_->PostTaskAndReply(
-      FROM_HERE, base::Bind(EnsureArchivesDirCreatedImpl, archives_dir_),
+      FROM_HERE, base::Bind(EnsureArchivesDirCreatedImpl, archive_dirs_),
       callback);
 }
 
 void ArchiveManager::ExistsArchive(const base::FilePath& archive_path,
                                    const base::Callback<void(bool)>& callback) {
   task_runner_->PostTask(
       FROM_HERE, base::Bind(ExistsArchiveImpl, archive_path,
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 void ArchiveManager::DeleteArchive(const base::FilePath& archive_path,
                                    const base::Callback<void(bool)>& callback) {
   std::vector<base::FilePath> archive_paths = {archive_path};
   DeleteMultipleArchives(archive_paths, callback);
 }
 
 void ArchiveManager::DeleteMultipleArchives(
     const std::vector<base::FilePath>& archive_paths,
     const base::Callback<void(bool)>& callback) {
   task_runner_->PostTask(
       FROM_HERE, base::Bind(DeleteArchivesImpl, archive_paths,
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 void ArchiveManager::GetAllArchives(
     const base::Callback<void(const std::set<base::FilePath>&)>& callback)
     const {
+  std::vector<base::FilePath> archive_dirs;
+  for (const auto& iter : archive_dirs_)
+    archive_dirs.push_back(iter.second);
   task_runner_->PostTask(
-      FROM_HERE, base::Bind(GetAllArchivesImpl, archives_dir_,
+      FROM_HERE, base::Bind(GetAllArchivesImpl, archive_dirs,
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 void ArchiveManager::GetStorageStats(
+    const std::set<LifetimeType>& lifetime_types,
     const StorageStatsCallback& callback) const {
+  std::vector<base::FilePath> archive_dirs;
+  for (const auto& type : lifetime_types)
+    archive_dirs.push_back(archive_dirs_.at(type));
+  DCHECK(archive_dirs.size());
   task_runner_->PostTask(
-      FROM_HERE, base::Bind(GetStorageStatsImpl, archives_dir_,
+      FROM_HERE, base::Bind(GetStorageStatsImpl, archive_dirs,
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 }  // namespace offline_pages