[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 464 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",

[Mark P, 2016/10/12 16:04:12]

I notice this moved from offline_page_metadata_store_sql.cc.  Is it still
emitted under exactly the same conditions  as before? (including error states)?

[fgorski, 2016/10/12 20:44:09]

Yes, because we are going to be calling the other method more often then simply
initialization in future. This had to be moved to post initialization call. We
would be reporting it far too much otherwise. Thanks for checking on that.

[Mark P, 2016/10/12 22:12:15]

Acknowledged.

+                       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()),
+      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