[Offline pages] Resetting offline page metadata store if initial load fails

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 287 matching lines @@
         1, kMaxOpenedPageHistogramBucket.InMinutes(), 50,
         base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(
       (access_time - offline_page_item.last_access_time).InMinutes());
 }
 
 }  // namespace
 
 // protected
 OfflinePageModelImpl::OfflinePageModelImpl()
-    : OfflinePageModel(), is_loaded_(false), weak_ptr_factory_(this) {}
+    : OfflinePageModel(),
+      is_loaded_(false),
+      store_reset_attempts_left_(3),
+      weak_ptr_factory_(this) {}
 
 OfflinePageModelImpl::OfflinePageModelImpl(
     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),
       policy_controller_(new ClientPolicyController()),
       archive_manager_(new ArchiveManager(archives_dir, task_runner)),
+      store_reset_attempts_left_(3),
       testing_clock_(nullptr),
       weak_ptr_factory_(this) {
   archive_manager_->EnsureArchivesDirCreated(
       base::Bind(&OfflinePageModelImpl::OnEnsureArchivesDirCreatedDone,
                  weak_ptr_factory_.GetWeakPtr(), base::TimeTicks::Now()));
 }
 
 OfflinePageModelImpl::~OfflinePageModelImpl() {}
 
 void OfflinePageModelImpl::AddObserver(Observer* observer) {
@@ skipping 441 matching lines @@
 
   // No need to fire OfflinePageModelChanged event since updating access info
   // should not have any impact to the UI.
 }
 
 void OfflinePageModelImpl::OnEnsureArchivesDirCreatedDone(
     const base::TimeTicks& start_time) {
   UMA_HISTOGRAM_TIMES("OfflinePages.Model.ArchiveDirCreationTime",
                       base::TimeTicks::Now() - start_time);
 
-  store_->GetOfflinePages(base::Bind(&OfflinePageModelImpl::OnLoadDone,
-                                     weak_ptr_factory_.GetWeakPtr(),
-                                     start_time));
+  store_->GetOfflinePages(
+      base::Bind(&OfflinePageModelImpl::OnGetOfflinePagesDoneForInit,
+                 weak_ptr_factory_.GetWeakPtr(), start_time));
 }
 
-void OfflinePageModelImpl::OnLoadDone(
+void OfflinePageModelImpl::OnGetOfflinePagesDoneForInit(
     const base::TimeTicks& start_time,
-    OfflinePageMetadataStore::LoadStatus load_status,
+    StoreState store_state,
     const std::vector<OfflinePageItem>& offline_pages) {
   DCHECK(!is_loaded_);
-  is_loaded_ = true;
+  UMA_HISTOGRAM_ENUMERATION(
+      "OfflinePages.StoreState", static_cast<int32_t>(store_state),
+      static_cast<int32_t>(StoreState::STORE_STATE_COUNT));
 
-  // TODO(jianli): rebuild the store upon failure.
+  if (store_state != StoreState::LOADED) {
+    DVLOG(1) << "Offline pages database loading failed: "
+             << static_cast<int32_t>(store_state);
+  }
 
-  if (load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED)
-    CacheLoadedData(offline_pages);
+  if (store_state == StoreState::FAILED_LOADING && MaybeResetStore(start_time))
+    return;
 
   UMA_HISTOGRAM_TIMES("OfflinePages.Model.ConstructionToLoadedEventTime",
                       base::TimeTicks::Now() - start_time);
+  UMA_HISTOGRAM_COUNTS("OfflinePages.SavedPageCount",
+                       static_cast<int32_t>(offline_pages.size()));
+
+  CacheLoadedData(offline_pages);
+  is_loaded_ = true;
 
   // Create Storage Manager.
   storage_manager_.reset(new OfflinePageStorageManager(
       this, GetPolicyController(), archive_manager_.get()));
 
   // Run all the delayed tasks.
   for (const auto& delayed_task : delayed_tasks_)
     delayed_task.Run();
   delayed_tasks_.clear();
 
   FOR_EACH_OBSERVER(Observer, observers_, OfflinePageModelLoaded(this));
 
   CheckMetadataConsistency();
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&OfflinePageModelImpl::ClearStorageIfNeeded,
                             weak_ptr_factory_.GetWeakPtr(),
                             base::Bind(&OfflinePageModelImpl::OnStorageCleared,
                                        weak_ptr_factory_.GetWeakPtr())),
       kStorageManagerStartingDelay);
 }
 
+bool OfflinePageModelImpl::MaybeResetStore(const base::TimeTicks& start_time) {
+  if (store_reset_attempts_left_ <= 0)
+    return false;
+
+  store_reset_attempts_left_--;
+  store_->Reset(base::Bind(&OfflinePageModelImpl::OnStoreResetDone,
+                           weak_ptr_factory_.GetWeakPtr(), start_time));
+  return true;
+}
+
+void OfflinePageModelImpl::OnStoreResetDone(const base::TimeTicks& start_time,
+                                            bool reset_success) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "OfflinePages.StoreState", static_cast<int32_t>(store_->state()),

[Dmitry Titov, 2016/11/15 20:23:46]

There is also another point of logging same UMA in OnGetOfflinePagesDoneForInit,
which will double-count successes I think. Probably should only log here if
(!reset_success)? Or do you want a separate UMA for successes of the reset?

+      static_cast<int32_t>(StoreState::STORE_STATE_COUNT));
+
+  if (reset_success) {
+    store_->GetOfflinePages(
+        base::Bind(&OfflinePageModelImpl::OnGetOfflinePagesDoneForInit,
+                   weak_ptr_factory_.GetWeakPtr(), start_time));
+    return;
+  }
+
+  if (store_->state() == StoreState::FAILED_RESET &&
+      MaybeResetStore(start_time)) {
+    return;
+  }
+
+  // Reset failed enough times. Simply initialize the model with no items.
+  OnGetOfflinePagesDoneForInit(start_time, store_->state(),
+                               std::vector<OfflinePageItem>());
+}
+
 void OfflinePageModelImpl::InformSavePageDone(const SavePageCallback& callback,
                                               SavePageResult result,
                                               const ClientId& client_id,
                                               int64_t offline_id) {
   ReportSavePageResultHistogramAfterSave(client_id, result);
   archive_manager_->GetStorageStats(
       base::Bind(&ReportStorageHistogramsAfterSave));
   callback.Run(result, offline_id);
 }
 
@@ skipping 217 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