Wipe out offline page data on clearing cookie and site data

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/sequenced_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/offline_pages/offline_page_item.h"
-#include "components/offline_pages/offline_page_metadata_store.h"
 #include "url/gurl.h"
 
 using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
 using SavePageResult = offline_pages::OfflinePageModel::SavePageResult;
 
 namespace offline_pages {
 
 namespace {
 
+// 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
+};
+
 // Threshold for how old offline copy of a page should be before we offer to
 // delete it to free up space.
 const base::TimeDelta kPageCleanUpThreshold = base::TimeDelta::FromDays(30);
 
 // The delay for the final deletion to kick in after the page is marked for
 // deletion. The value set here is a bit longer that the duration of the
 // snackbar that offers undo.
 const base::TimeDelta kFinalDeletionDelay = base::TimeDelta::FromSeconds(6);
 
 SavePageResult ToSavePageResult(ArchiverResult archiver_result) {
@@ skipping 171 matching lines @@
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DeleteArchiveFiles, paths_to_delete, success),
       base::Bind(&OfflinePageModel::OnDeleteArchiveFilesDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  bookmark_ids,
                  callback,
                  base::Owned(success)));
 }
 
+void OfflinePageModel::ClearAll(const base::Closure& callback) {
+  DCHECK(is_loaded_);
+
+  std::vector<int64> bookmark_ids;
+  for (const auto& id_page_pair : offline_pages_)
+    bookmark_ids.push_back(id_page_pair.first);
+  DeletePagesByBookmarkId(
+      bookmark_ids,
+      base::Bind(&OfflinePageModel::OnRemoveAllFilesDoneForClearAll,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback));
+}
+
 const std::vector<OfflinePageItem> OfflinePageModel::GetAllPages() const {
   DCHECK(is_loaded_);
   std::vector<OfflinePageItem> offline_pages;
   for (const auto& id_page_pair : offline_pages_) {
     if (id_page_pair.second.IsMarkedForDeletion())
       continue;
     offline_pages.push_back(id_page_pair.second);
   }
   return offline_pages;
 }
@@ skipping 198 matching lines @@
         base::Bind(&OfflinePageModel::MarkPageForDeletion,
                    weak_ptr_factory_.GetWeakPtr(),
                    node->id(),
                    base::Bind(&EmptyDeleteCallback)));
     return;
   }
   MarkPageForDeletion(node->id(), base::Bind(&EmptyDeleteCallback));
 }
 
 void OfflinePageModel::OnLoadDone(
-    bool success,
+    OfflinePageMetadataStore::LoadStatus load_status,
     const std::vector<OfflinePageItem>& offline_pages) {
   DCHECK(!is_loaded_);
   is_loaded_ = true;
 
-  if (success) {
-    for (const auto& offline_page : offline_pages)
-      offline_pages_[offline_page.bookmark_id] = offline_page;
-  }
+  // TODO(jianli): rebuild the store upon failure.
+
+  UMA_HISTOGRAM_ENUMERATION("OfflinePages.LoadStatus",
+                            load_status,
+                            OfflinePageMetadataStore::LOAD_STATUS_COUNT);
+  if (load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED)
+    CacheLoadedData(offline_pages);
 
   // Run all the delayed tasks.
   for (const auto& delayed_task : delayed_tasks_)
     delayed_task.Run();
   delayed_tasks_.clear();
 
   // If there are pages that are marked for deletion, but not yet deleted and
   // OfflinePageModel gets reloaded. Delete the pages now.
   FinalizePageDeletion();
 
@@ skipping 88 matching lines @@
 }
 
 void OfflinePageModel::OnRemoveOfflinePagesMissingArchiveFileDone(
     const std::vector<int64>& bookmark_ids,
     OfflinePageModel::DeletePageResult /* result */) {
   for (int64 bookmark_id : bookmark_ids) {
     FOR_EACH_OBSERVER(Observer, observers_, OfflinePageDeleted(bookmark_id));
   }
 }
 
+void OfflinePageModel::OnRemoveAllFilesDoneForClearAll(
+    const base::Closure& callback,
+    DeletePageResult result) {
+  store_->Reset(base::Bind(&OfflinePageModel::OnResetStoreDoneForClearAll,
+                           weak_ptr_factory_.GetWeakPtr(),
+                           callback));
+}
+
+void OfflinePageModel::OnResetStoreDoneForClearAll(
+    const base::Closure& callback, bool success) {
+  DCHECK(success);

[fgorski, 2015/10/27 20:13:09]

DCHECK makes sense :)

+  UMA_HISTOGRAM_ENUMERATION("OfflinePages.ClearAllStatus",
+                            STORE_RESET_FAILED,
+                            CLEAR_ALL_STATUS_COUNT);
+
+  offline_pages_.clear();
+  store_->Load(base::Bind(&OfflinePageModel::OnReloadStoreDoneForClearAll,
+                          weak_ptr_factory_.GetWeakPtr(),
+                          callback));
+}
+
+void OfflinePageModel::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.ClearAllStatus",
+      load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED ?
+          CLEAR_ALL_SUCCEEDED : STORE_RELOAD_FAILED,
+      CLEAR_ALL_STATUS_COUNT);
+
+  CacheLoadedData(offline_pages);
+  callback.Run();
+}
+
+void OfflinePageModel::CacheLoadedData(
+    const std::vector<OfflinePageItem>& offline_pages) {
+  offline_pages_.clear();
+  for (const auto& offline_page : offline_pages)
+    offline_pages_[offline_page.bookmark_id] = offline_page;
+}
+
 }  // namespace offline_pages