[Offline Pages] Removes two-step expiration related.

components/offline_pages/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/offline_page_model_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 359 matching lines @@
 
 void OfflinePageModelImpl::MarkPageAccessed(int64_t offline_id) {
   RunWhenLoaded(base::Bind(&OfflinePageModelImpl::MarkPageAccessedWhenLoadDone,
                            weak_ptr_factory_.GetWeakPtr(), offline_id));
 }
 
 void OfflinePageModelImpl::MarkPageAccessedWhenLoadDone(int64_t offline_id) {
   DCHECK(is_loaded_);
 
   auto iter = offline_pages_.find(offline_id);
-  if (iter == offline_pages_.end() || iter->second.IsExpired())
+  if (iter == offline_pages_.end())
     return;
 
   // Make a copy of the cached item and update it. The cached item should only
   // be updated upon the successful store operation.
   OfflinePageItem offline_page_item = iter->second;
 
   ReportPageHistogramsAfterAccess(offline_page_item, GetCurrentTime());
 
   offline_page_item.last_access_time = GetCurrentTime();
   offline_page_item.access_count++;
@@ skipping 13 matching lines @@
 }
 
 void OfflinePageModelImpl::DoDeletePagesByOfflineId(
     const std::vector<int64_t>& offline_ids,
     const DeletePageCallback& callback) {
   DCHECK(is_loaded_);
 
   std::vector<base::FilePath> paths_to_delete;
   for (const auto& offline_id : offline_ids) {
     auto iter = offline_pages_.find(offline_id);
-    if (iter != offline_pages_.end() && !iter->second.IsExpired()) {
+    if (iter != offline_pages_.end()) {
       paths_to_delete.push_back(iter->second.file_path);
     }
   }
 
   // If there're no pages to delete, return early.
   if (paths_to_delete.empty()) {
     InformDeletePageDone(callback, DeletePageResult::SUCCESS);
     return;
   }
 
   archive_manager_->DeleteMultipleArchives(
       paths_to_delete,
       base::Bind(&OfflinePageModelImpl::OnDeleteArchiveFilesDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_ids, callback));
 }
 
 void OfflinePageModelImpl::DeletePagesByClientIds(
     const std::vector<ClientId>& client_ids,
     const DeletePageCallback& callback) {
   OfflinePageModelQueryBuilder builder;
-  builder
-      .SetClientIds(OfflinePageModelQuery::Requirement::INCLUDE_MATCHING,
-                    client_ids)
-      .AllowExpiredPages(true);
+  builder.SetClientIds(OfflinePageModelQuery::Requirement::INCLUDE_MATCHING,
+                       client_ids);
   auto delete_pages = base::Bind(&OfflinePageModelImpl::DeletePages,
                                  weak_ptr_factory_.GetWeakPtr(), callback);
   RunWhenLoaded(base::Bind(&OfflinePageModelImpl::GetPagesMatchingQuery,
                            weak_ptr_factory_.GetWeakPtr(),
                            base::Passed(builder.Build(GetPolicyController())),
                            delete_pages));
 }
 
 void OfflinePageModelImpl::DeletePages(
     const DeletePageCallback& callback,
@@ skipping 83 matching lines @@
 
 void OfflinePageModelImpl::GetAllPages(
     const MultipleOfflinePageItemCallback& callback) {
   OfflinePageModelQueryBuilder builder;
   RunWhenLoaded(base::Bind(&OfflinePageModelImpl::GetPagesMatchingQuery,
                            weak_ptr_factory_.GetWeakPtr(),
                            base::Passed(builder.Build(GetPolicyController())),
                            callback));
 }
 
-void OfflinePageModelImpl::GetAllPagesWithExpired(
-    const MultipleOfflinePageItemCallback& callback) {
-  OfflinePageModelQueryBuilder builder;
-  builder.AllowExpiredPages(true);
-
-  RunWhenLoaded(base::Bind(&OfflinePageModelImpl::GetPagesMatchingQuery,
-                           weak_ptr_factory_.GetWeakPtr(),
-                           base::Passed(builder.Build(GetPolicyController())),
-                           callback));
-}
-
 void OfflinePageModelImpl::GetOfflineIdsForClientId(
     const ClientId& client_id,
     const MultipleOfflineIdCallback& callback) {
   RunWhenLoaded(
       base::Bind(&OfflinePageModelImpl::GetOfflineIdsForClientIdWhenLoadDone,
                  weak_ptr_factory_.GetWeakPtr(), client_id, callback));
 }
 
 void OfflinePageModelImpl::GetOfflineIdsForClientIdWhenLoadDone(
     const ClientId& client_id,
     const MultipleOfflineIdCallback& callback) const {
   callback.Run(MaybeGetOfflineIdsForClientId(client_id));
 }
 
 const std::vector<int64_t> OfflinePageModelImpl::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(fgorski): 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 &&
-        !id_page_pair.second.IsExpired()) {
+    if (id_page_pair.second.client_id == client_id)
       results.push_back(id_page_pair.second.offline_id);
-    }
   }
   return results;
 }
 
 void OfflinePageModelImpl::GetPageByOfflineId(
     int64_t offline_id,
     const SingleOfflinePageItemCallback& callback) {
   std::vector<int64_t> query_ids;
   query_ids.emplace_back(offline_id);
 
@@ skipping 35 matching lines @@
     const MultipleOfflinePageItemCallback& callback) const {
   std::vector<OfflinePageItem> result;
 
   GURL::Replacements remove_params;
   remove_params.ClearRef();
 
   GURL url_without_fragment =
       url.ReplaceComponents(remove_params);
 
   for (const auto& id_page_pair : offline_pages_) {
-    if (id_page_pair.second.IsExpired())
-      continue;
     // First, search by last committed URL with fragment stripped.
     if (url_without_fragment ==
             id_page_pair.second.url.ReplaceComponents(remove_params)) {
       result.push_back(id_page_pair.second);
       continue;
     }
     // Then, search by original request URL if |url_search_mode| wants it.
     // Note that we want to do the exact match with fragment included. This is
     // because original URL is used for redirect purpose and it is always safer
     // to support the exact redirect.
     if (url_search_mode == URLSearchMode::SEARCH_BY_ALL_URLS &&
         url == id_page_pair.second.original_url) {
       result.push_back(id_page_pair.second);
     }
   }
 
   callback.Run(result);
 }
 
 void OfflinePageModelImpl::CheckMetadataConsistency() {
   archive_manager_->GetAllArchives(
       base::Bind(&OfflinePageModelImpl::CheckMetadataConsistencyForArchivePaths,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void OfflinePageModelImpl::ExpirePages(
-    const std::vector<int64_t>& offline_ids,
-    const base::Time& expiration_time,
-    const base::Callback<void(bool)>& callback) {
-  std::vector<base::FilePath> paths_to_delete;
-  std::vector<OfflinePageItem> items_to_update;
-  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;
-    paths_to_delete.push_back(offline_page.file_path);
-    offline_page.expiration_time = expiration_time;
-
-    items_to_update.push_back(offline_page);
-  }
-
-  store_->UpdateOfflinePages(
-      items_to_update,
-      base::Bind(&OfflinePageModelImpl::OnExpirePageDone,
-                 weak_ptr_factory_.GetWeakPtr(), expiration_time));
-
-  if (paths_to_delete.empty()) {
-    callback.Run(true);
-    return;
-  }
-  archive_manager_->DeleteMultipleArchives(paths_to_delete, callback);
-}
-
-void OfflinePageModelImpl::OnExpirePageDone(
-    const base::Time& expiration_time,
-    std::unique_ptr<OfflinePagesUpdateResult> result) {
-  UMA_HISTOGRAM_BOOLEAN("OfflinePages.ExpirePage.StoreUpdateResult",
-                        result->updated_items.size() > 0);
-  for (const auto& expired_page : result->updated_items) {
-    const auto& iter = offline_pages_.find(expired_page.offline_id);
-    if (iter == offline_pages_.end())
-      continue;
-
-    iter->second.expiration_time = expiration_time;
-    ClientId client_id = iter->second.client_id;
-    offline_event_logger_.RecordPageExpired(
-        std::to_string(expired_page.offline_id));
-    base::HistogramBase* histogram = base::Histogram::FactoryGet(
-        AddHistogramSuffix(client_id, "OfflinePages.ExpirePage.PageLifetime"),
-        1, base::TimeDelta::FromDays(30).InMinutes(), 50,
-        base::HistogramBase::kUmaTargetedHistogramFlag);
-    histogram->Add((expiration_time - iter->second.creation_time).InMinutes());
-    histogram = base::Histogram::FactoryGet(
-        AddHistogramSuffix(client_id,
-                           "OfflinePages.ExpirePage.TimeSinceLastAccess"),
-        1, base::TimeDelta::FromDays(30).InMinutes(), 50,
-        base::HistogramBase::kUmaTargetedHistogramFlag);
-    histogram->Add(
-        (expiration_time - iter->second.last_access_time).InMinutes());
-  }
-}
-
 ClientPolicyController* OfflinePageModelImpl::GetPolicyController() {
   return policy_controller_.get();
 }
 
 OfflinePageMetadataStore* OfflinePageModelImpl::GetStoreForTesting() {
   return store_.get();
 }
 
 OfflinePageStorageManager* OfflinePageModelImpl::GetStorageManager() {
   return storage_manager_.get();
@@ skipping 294 matching lines @@
                             static_cast<int>(result),
                             static_cast<int>(DeletePageResult::RESULT_COUNT));
   archive_manager_->GetStorageStats(
       base::Bind(&ReportStorageHistogramsAfterDelete));
   if (!callback.is_null())
     callback.Run(result);
 }
 
 void OfflinePageModelImpl::CheckMetadataConsistencyForArchivePaths(
     const std::set<base::FilePath>& archive_paths) {
-  ExpirePagesMissingArchiveFile(archive_paths);
+  DeletePagesMissingArchiveFile(archive_paths);
   DeleteOrphanedArchives(archive_paths);
 }
 
-void OfflinePageModelImpl::ExpirePagesMissingArchiveFile(
+void OfflinePageModelImpl::DeletePagesMissingArchiveFile(
     const std::set<base::FilePath>& archive_paths) {
   std::vector<int64_t> ids_of_pages_missing_archive_file;
   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);
   }
 
   if (ids_of_pages_missing_archive_file.empty())
     return;
 
-  ExpirePages(
-      ids_of_pages_missing_archive_file, GetCurrentTime(),
-      base::Bind(&OfflinePageModelImpl::OnExpirePagesMissingArchiveFileDone,
+  DeletePagesByOfflineId(
+      ids_of_pages_missing_archive_file,
+      base::Bind(&OfflinePageModelImpl::OnDeletePagesMissingArchiveFileDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  ids_of_pages_missing_archive_file));
 }
 
-void OfflinePageModelImpl::OnExpirePagesMissingArchiveFileDone(
+void OfflinePageModelImpl::OnDeletePagesMissingArchiveFileDone(
     const std::vector<int64_t>& offline_ids,
-    bool success) {
+    DeletePageResult result) {
   UMA_HISTOGRAM_COUNTS("OfflinePages.Consistency.PagesMissingArchiveFileCount",
                        static_cast<int32_t>(offline_ids.size()));
-  UMA_HISTOGRAM_BOOLEAN(
-      "OfflinePages.Consistency.ExpirePagesMissingArchiveFileResult", success);
+  UMA_HISTOGRAM_ENUMERATION(
+      "OfflinePages.Consistency.DeletePagesMissingArchiveFileResult",
+      static_cast<int>(result),
+      static_cast<int>(DeletePageResult::RESULT_COUNT));
 }
 
 void OfflinePageModelImpl::DeleteOrphanedArchives(
     const std::set<base::FilePath>& archive_paths) {
   // Archives are considered orphaned unless they are pointed to by some pages.
   std::set<base::FilePath> orphaned_archive_set(archive_paths);
   for (const auto& id_page_pair : offline_pages_)
     orphaned_archive_set.erase(id_page_pair.second.file_path);
 
   if (orphaned_archive_set.empty())
@@ skipping 26 matching lines @@
 void OfflinePageModelImpl::ClearStorageIfNeeded(
     const ClearStorageCallback& callback) {
   // Create Storage Manager if necessary.
   if (!storage_manager_) {
     storage_manager_.reset(new OfflinePageStorageManager(
         this, GetPolicyController(), archive_manager_.get()));
   }
   storage_manager_->ClearPagesIfNeeded(callback);
 }
 
-void OfflinePageModelImpl::OnStorageCleared(size_t expired_page_count,
+void OfflinePageModelImpl::OnStorageCleared(size_t deleted_page_count,
                                             ClearStorageResult result) {
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.ClearStorageResult",
                             static_cast<int>(result),
                             static_cast<int>(ClearStorageResult::RESULT_COUNT));
-  if (expired_page_count > 0) {
-    UMA_HISTOGRAM_COUNTS("OfflinePages.ExpirePage.BatchSize",
-                         static_cast<int32_t>(expired_page_count));
+  if (deleted_page_count > 0) {
+    UMA_HISTOGRAM_COUNTS("OfflinePages.ClearStorageBatchSize",
+                         static_cast<int32_t>(deleted_page_count));
   }
 }
 
 void OfflinePageModelImpl::PostClearStorageIfNeededTask(bool delayed) {
   base::TimeDelta delay =
       delayed ? kStorageManagerStartingDelay : base::TimeDelta();
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&OfflinePageModelImpl::ClearStorageIfNeeded,
                             weak_ptr_factory_.GetWeakPtr(),
                             base::Bind(&OfflinePageModelImpl::OnStorageCleared,
@@ skipping 14 matching lines @@
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 base::Time OfflinePageModelImpl::GetCurrentTime() const {
   return testing_clock_ ? testing_clock_->Now() : base::Time::Now();
 }
 
 }  // namespace offline_pages