[Offline pages] Hooking up Archive Manager to Offline 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;
 
 namespace offline_pages {
 
@@ skipping 40 matching lines @@
     case ArchiverResult::ERROR_SECURITY_CERTIFICATE:
       result = SavePageResult::SECURITY_CERTIFICATE_ERROR;
       break;
     default:
       NOTREACHED();
       result = SavePageResult::CONTENT_UNAVAILABLE;
   }
   return result;
 }
 
-void DeleteArchiveFiles(const std::vector<base::FilePath>& paths_to_delete,
-                        bool* success) {
-  DCHECK(success);
-  for (const auto& file_path : paths_to_delete) {
-    // Make sure delete happens on the left of || so that it is always executed.
-    *success = base::DeleteFile(file_path, false) || *success;
-  }
-}
-
-void FindPagesMissingArchiveFile(
-    const std::vector<std::pair<int64_t, base::FilePath>>& id_path_pairs,
-    std::vector<int64_t>* ids_of_pages_missing_archive_file) {
-  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));
-}
-
 }  // namespace
 
 // static
 bool OfflinePageModel::CanSavePage(const GURL& url) {
   return url.SchemeIsHTTPOrHTTPS();
 }
 
 // protected
 OfflinePageModel::OfflinePageModel()
     : is_loaded_(false), weak_ptr_factory_(this) {}
 
 OfflinePageModel::OfflinePageModel(
     std::unique_ptr<OfflinePageMetadataStore> store,
     const base::FilePath& archives_dir,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : store_(std::move(store)),
       archives_dir_(archives_dir),
       is_loaded_(false),
-      task_runner_(task_runner),
       policy_controller_(new ClientPolicyController()),
+      archive_manager_(new ArchiveManager(archives_dir, task_runner)),
       weak_ptr_factory_(this) {
-  task_runner_->PostTaskAndReply(
-      FROM_HERE, base::Bind(EnsureArchivesDirCreated, archives_dir_),
+  archive_manager_->EnsureArchivesDirCreated(
       base::Bind(&OfflinePageModel::OnEnsureArchivesDirCreatedDone,
                  weak_ptr_factory_.GetWeakPtr(), base::TimeTicks::Now()));
 }
 
 OfflinePageModel::~OfflinePageModel() {
 }
 
 void OfflinePageModel::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 87 matching lines @@
     if (iter != offline_pages_.end()) {
       paths_to_delete.push_back(iter->second.file_path);
     }
   }
 
   if (paths_to_delete.empty()) {
     InformDeletePageDone(callback, DeletePageResult::NOT_FOUND);
     return;
   }
 
-  bool* success = new bool(false);
-  task_runner_->PostTaskAndReply(
-      FROM_HERE, base::Bind(&DeleteArchiveFiles, paths_to_delete, success),
+  archive_manager_->DeleteMultipleArchives(
+      paths_to_delete,
       base::Bind(&OfflinePageModel::OnDeleteArchiveFilesDone,
-                 weak_ptr_factory_.GetWeakPtr(), offline_ids, callback,
-                 base::Owned(success)));
+                 weak_ptr_factory_.GetWeakPtr(), offline_ids, callback));
 }
 
 void OfflinePageModel::ClearAll(const base::Closure& callback) {
   DCHECK(is_loaded_);
 
   std::vector<int64_t> offline_ids;
   for (const auto& id_page_pair : offline_pages_)
     offline_ids.push_back(id_page_pair.first);
   DeletePagesByOfflineId(
       offline_ids,
@@ skipping 96 matching lines @@
       base::Bind(&OfflinePageModel::GetOfflineIdsForClientIdWhenLoadDone,
                  weak_ptr_factory_.GetWeakPtr(), client_id, callback));
 }
 
 void OfflinePageModel::GetOfflineIdsForClientIdWhenLoadDone(
     const ClientId& client_id,
     const MultipleOfflineIdCallback& callback) const {
   callback.Run(MaybeGetOfflineIdsForClientId(client_id));
 }
 
-// TODO(fgorski): Remove include_deleted, as it no longer makes sense.
 const std::vector<int64_t> OfflinePageModel::MaybeGetOfflineIdsForClientId(
     const ClientId& client_id) const {
   DCHECK(is_loaded_);
   std::vector<int64_t> results;
 
   // We want only all pages, including those marked for deletion.
   // TODO(bburns): actually use an index rather than linear scan.
   for (const auto& id_page_pair : offline_pages_) {
     if (id_page_pair.second.client_id == client_id)
       results.push_back(id_page_pair.second.offline_id);
@@ skipping 106 matching lines @@
       if (!result || id_page_pair.second.creation_time > result->creation_time)
         result = &(id_page_pair.second);
     }
   }
   return result;
 }
 
 void OfflinePageModel::CheckForExternalFileDeletion() {
   DCHECK(is_loaded_);
 
-  std::vector<std::pair<int64_t, base::FilePath>> id_path_pairs;
-  for (const auto& id_page_pair : offline_pages_) {
-    id_path_pairs.push_back(
-        std::make_pair(id_page_pair.first, id_page_pair.second.file_path));
-  }
-
-  std::vector<int64_t>* ids_of_pages_missing_archive_file =
-      new std::vector<int64_t>();
-  task_runner_->PostTaskAndReply(
-      FROM_HERE, base::Bind(&FindPagesMissingArchiveFile, id_path_pairs,
-                            ids_of_pages_missing_archive_file),
-      base::Bind(&OfflinePageModel::OnFindPagesMissingArchiveFile,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Owned(ids_of_pages_missing_archive_file)));
+  archive_manager_->GetAllArchives(
+      base::Bind(&OfflinePageModel::ScanForMissingArchivePaths,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OfflinePageModel::RecordStorageHistograms(int64_t total_space_bytes,
                                                int64_t free_space_bytes,
                                                bool reporting_after_delete) {
   // Total space taken by offline pages.
   int64_t total_page_size = 0;
   for (const auto& id_page_pair : offline_pages_) {
     total_page_size += id_page_pair.second.file_size;
   }
@@ skipping 151 matching lines @@
 }
 
 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,
     const DeletePageCallback& callback,
-    const bool* success) {
-  DCHECK(success);
-
-  if (!*success) {
+    bool success) {
+  if (!success) {
     InformDeletePageDone(callback, DeletePageResult::DEVICE_FAILURE);
     return;
   }
 
   store_->RemoveOfflinePages(
       offline_ids,
       base::Bind(&OfflinePageModel::OnRemoveOfflinePagesDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_ids, callback));
 }
 
@@ skipping 52 matching lines @@
 void OfflinePageModel::InformDeletePageDone(const DeletePageCallback& callback,
                                             DeletePageResult result) {
   UMA_HISTOGRAM_ENUMERATION(
       "OfflinePages.DeletePageResult",
       static_cast<int>(result),
       static_cast<int>(DeletePageResult::RESULT_COUNT));
   if (!callback.is_null())
     callback.Run(result);
 }
 
-void OfflinePageModel::OnFindPagesMissingArchiveFile(
-    const std::vector<int64_t>* ids_of_pages_missing_archive_file) {
-  DCHECK(ids_of_pages_missing_archive_file);
-  if (ids_of_pages_missing_archive_file->empty())
-    return;
-
+void OfflinePageModel::ScanForMissingArchivePaths(

[jianli, 2016/05/17 21:48:13]

nit: ScanForMissingArchiveFiles

[fgorski, 2016/05/17 22:50:29]

Done.

+    const std::set<base::FilePath>& archive_paths) {
+  std::vector<int64_t> ids_of_pages_missing_archive_file;
   std::vector<std::pair<int64_t, ClientId>> offline_client_id_pairs;
-  for (auto offline_id : *ids_of_pages_missing_archive_file) {
-    // Since we might have deleted pages in between so we have to purge
-    // the list to make sure we still care about them.
-    auto iter = offline_pages_.find(offline_id);
-    if (iter != offline_pages_.end()) {
+  for (const auto& id_page_pair : offline_pages_) {
+    if (archive_paths.count(id_page_pair.second.file_path) == 0UL) {
+      ids_of_pages_missing_archive_file.push_back(id_page_pair.first);
       offline_client_id_pairs.push_back(
-          std::make_pair(offline_id, iter->second.client_id));
+          std::make_pair(id_page_pair.first, id_page_pair.second.client_id));
     }
   }
 
-  DeletePageCallback done_callback(
+  // No offline pages missing archive files, we can bail out.
+  if (ids_of_pages_missing_archive_file.empty())
+    return;
+
+  DeletePageCallback remove_pages_done_callback(
       base::Bind(&OfflinePageModel::OnRemoveOfflinePagesMissingArchiveFileDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_client_id_pairs));
 
   store_->RemoveOfflinePages(
-      *ids_of_pages_missing_archive_file,
+      ids_of_pages_missing_archive_file,
       base::Bind(&OfflinePageModel::OnRemoveOfflinePagesDone,
                  weak_ptr_factory_.GetWeakPtr(),
-                 *ids_of_pages_missing_archive_file,
-                 done_callback));
+                 ids_of_pages_missing_archive_file,
+                 remove_pages_done_callback));
 }
 
 void OfflinePageModel::OnRemoveOfflinePagesMissingArchiveFileDone(
     const std::vector<std::pair<int64_t, ClientId>>& offline_client_id_pairs,
     DeletePageResult /* result */) {
   for (const auto& id_pair : offline_client_id_pairs) {
     FOR_EACH_OBSERVER(Observer, observers_,
                       OfflinePageDeleted(id_pair.first, id_pair.second));
   }
 }
@@ skipping 50 matching lines @@
 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