[Offline Pages] Two-step expiration in storage manager.

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"
@@ skipping 490 matching lines @@
 
 void OfflinePageModel::CheckForExternalFileDeletion() {
   DCHECK(is_loaded_);
 
   archive_manager_->GetAllArchives(
       base::Bind(&OfflinePageModel::ScanForMissingArchiveFiles,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OfflinePageModel::ExpirePages(const std::vector<int64_t>& offline_ids,
-                                   const base::Time& expiration_time) {
+                                   const base::Time& expiration_time,
+                                   const DeletePageCallback& callback) {
   for (int64_t offline_id : offline_ids) {
     auto iter = offline_pages_.find(offline_id);
     if (iter == offline_pages_.end())
       continue;
 
     OfflinePageItem offline_page = iter->second;
     offline_page.expiration_time = expiration_time;
 
     store_->AddOrUpdateOfflinePage(
         offline_page, base::Bind(&OfflinePageModel::OnExpirePageDone,
                                  weak_ptr_factory_.GetWeakPtr(), offline_id,
                                  expiration_time));
   }
+  DeletePagesByOfflineId(offline_ids, callback);

[jianli, 2016/05/24 23:43:32]

I don't think we want to delete offline page metadata record from the store. We
only intend to delete the offline file.

[romax, 2016/05/25 20:05:23]

Done.

+}
+
+void OfflinePageModel::RemovePageItems(
+    const std::vector<int64_t>& offline_ids,
+    const base::Callback<void(bool)>& callback) {
+  store_->RemoveOfflinePages(offline_ids, callback);
 }
 
 void OfflinePageModel::OnExpirePageDone(int64_t offline_id,
                                         const base::Time& expiration_time,
                                         bool success) {
   // TODO(romax): Report UMA about successful expiration.
   if (success) {
     auto iter = offline_pages_.find(offline_id);
     if (iter != offline_pages_.end())
       iter->second.expiration_time = expiration_time;
@@ skipping 145 matching lines @@
 
 void OfflinePageModel::OnDeleteArchiveFilesDone(
     const std::vector<int64_t>& offline_ids,
     const DeletePageCallback& callback,
     bool success) {
   if (!success) {
     InformDeletePageDone(callback, DeletePageResult::DEVICE_FAILURE);
     return;
   }
 
-  store_->RemoveOfflinePages(
+  RemovePageItems(
       offline_ids,
       base::Bind(&OfflinePageModel::OnRemoveOfflinePagesDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_ids, callback));
 }
 
 void OfflinePageModel::OnRemoveOfflinePagesDone(
     const std::vector<int64_t>& offline_ids,
     const DeletePageCallback& callback,
     bool success) {
   // Delete the offline page from the in memory cache regardless of success in
@@ skipping 77 matching lines @@
   }
 
   // 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,
-      base::Bind(&OfflinePageModel::OnRemoveOfflinePagesDone,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 ids_of_pages_missing_archive_file,
-                 remove_pages_done_callback));
+  RemovePageItems(ids_of_pages_missing_archive_file,
+                  base::Bind(&OfflinePageModel::OnRemoveOfflinePagesDone,
+                             weak_ptr_factory_.GetWeakPtr(),
+                             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