Offline Pages - Removes the "ClearAllPages" API.

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 23 matching lines @@
 
 namespace offline_pages {
 
 namespace {
 
 // The delay used to schedule the first clear storage request for storage
 // manager after the model is loaded.
 const base::TimeDelta kStorageManagerStartingDelay =
     base::TimeDelta::FromSeconds(20);
 
-// 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,
-  STORE_RELOAD_FAILED,
-
-  // NOTE: always keep this entry at the end.
-  CLEAR_ALL_STATUS_COUNT
-};
-
 int64_t GenerateOfflineId() {
   return base::RandGenerator(std::numeric_limits<int64_t>::max()) + 1;
 }
 
 // The maximum histogram size for the metrics that measure time between views of
 // a given page.
 const base::TimeDelta kMaxOpenedPageHistogramBucket =
     base::TimeDelta::FromDays(90);
 
 SavePageResult ToSavePageResult(ArchiverResult archiver_result) {
@@ skipping 367 matching lines @@
     InformDeletePageDone(callback, DeletePageResult::SUCCESS);
     return;
   }
 
   archive_manager_->DeleteMultipleArchives(
       paths_to_delete,
       base::Bind(&OfflinePageModelImpl::OnDeleteArchiveFilesDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_ids, callback));
 }
 
-void OfflinePageModelImpl::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,
-      base::Bind(&OfflinePageModelImpl::OnRemoveAllFilesDoneForClearAll,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
-}
-
 void OfflinePageModelImpl::DeleteCachedPagesByURLPredicate(
     const UrlPredicate& predicate,
     const DeletePageCallback& callback) {
   RunWhenLoaded(
       base::Bind(&OfflinePageModelImpl::DoDeleteCachedPagesByURLPredicate,
                  weak_ptr_factory_.GetWeakPtr(), predicate, callback));
 }
 
 void OfflinePageModelImpl::DoDeleteCachedPagesByURLPredicate(
     const UrlPredicate& predicate,
@@ skipping 584 matching lines @@
 
 void OfflinePageModelImpl::OnDeleteOrphanedArchivesDone(
     const std::vector<base::FilePath>& archives,
     bool success) {
   UMA_HISTOGRAM_COUNTS("OfflinePages.Consistency.OrphanedArchivesCount",
                        static_cast<int32_t>(archives.size()));
   UMA_HISTOGRAM_BOOLEAN("OfflinePages.Consistency.DeleteOrphanedArchivesResult",
                         success);
 }
 
-void OfflinePageModelImpl::OnRemoveAllFilesDoneForClearAll(
-    const base::Closure& callback,
-    DeletePageResult result) {
-  store_->Reset(base::Bind(&OfflinePageModelImpl::OnResetStoreDoneForClearAll,
-                           weak_ptr_factory_.GetWeakPtr(), callback));
-}
-
-void OfflinePageModelImpl::OnResetStoreDoneForClearAll(
-    const base::Closure& callback,
-    bool success) {
-  DCHECK(success);
-  if (!success) {
-    offline_event_logger_.RecordStoreClearError();
-    UMA_HISTOGRAM_ENUMERATION("OfflinePages.ClearAllStatus2",
-                              STORE_RESET_FAILED, CLEAR_ALL_STATUS_COUNT);
-  }
-
-  offline_pages_.clear();
-  store_->GetOfflinePages(
-      base::Bind(&OfflinePageModelImpl::OnReloadStoreDoneForClearAll,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
-}
-
-void OfflinePageModelImpl::OnReloadStoreDoneForClearAll(
-    const base::Closure& callback,
-    OfflinePageMetadataStore::LoadStatus load_status,
-    const std::vector<OfflinePageItem>& offline_pages) {
-  DCHECK_EQ(OfflinePageMetadataStore::LOAD_SUCCEEDED, load_status);
-  UMA_HISTOGRAM_ENUMERATION(
-      "OfflinePages.ClearAllStatus2",
-      load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED
-          ? CLEAR_ALL_SUCCEEDED
-          : STORE_RELOAD_FAILED,
-      CLEAR_ALL_STATUS_COUNT);
-
-  if (load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED) {
-    offline_event_logger_.RecordStoreCleared();
-  } else {
-    offline_event_logger_.RecordStoreReloadError();
-  }
-
-  CacheLoadedData(offline_pages);
-  callback.Run();
-}
-
 void OfflinePageModelImpl::CacheLoadedData(
     const std::vector<OfflinePageItem>& offline_pages) {
   offline_pages_.clear();
   for (const auto& offline_page : offline_pages)
     offline_pages_[offline_page.offline_id] = offline_page;
 }
 
 void OfflinePageModelImpl::ClearStorageIfNeeded(
     const ClearStorageCallback& callback) {
   storage_manager_->ClearPagesIfNeeded(callback);
@@ skipping 31 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