[Offline pages] Resetting offline page metadata store to handle LOAD/INIT failures

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 629 matching lines @@
     if (online_url_without_fragment ==
         id_page_pair.second.url.ReplaceComponents(remove_params)) {
       result.push_back(id_page_pair.second);
     }
   }
 
   callback.Run(result);
 }
 
 void OfflinePageModelImpl::CheckMetadataConsistency() {
-  DCHECK(is_loaded_);
   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;
@@ skipping 148 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_->Initialize(base::Bind(&OfflinePageModelImpl::OnStoreInitialized,
+                                weak_ptr_factory_.GetWeakPtr(), start_time));
+}
+
+void OfflinePageModelImpl::OnStoreInitialized(const base::TimeTicks& start_time,
+                                              StoreState state) {
+  if (state == StoreState::FAILED_RESET) {
+    CompleteLoad();
+    return;
+  }
+
+  if (state == StoreState::FAILED_LOADING) {
+    store_->Reset(base::Bind(&OfflinePageModelImpl::OnStoreInitialized,
+                             weak_ptr_factory_.GetWeakPtr(), start_time));
+    return;
+  }
+
+  DCHECK_EQ(state, StoreState::LOADED);
   store_->GetOfflinePages(base::Bind(&OfflinePageModelImpl::OnLoadDone,
                                      weak_ptr_factory_.GetWeakPtr(),
                                      start_time));
 }
 
 void OfflinePageModelImpl::OnLoadDone(
     const base::TimeTicks& start_time,
-    OfflinePageMetadataStore::LoadStatus load_status,
     const std::vector<OfflinePageItem>& offline_pages) {
   DCHECK(!is_loaded_);
-  is_loaded_ = true;
-
-  // TODO(jianli): rebuild the store upon failure.
-
-  if (load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED)
-    CacheLoadedData(offline_pages);
 
   UMA_HISTOGRAM_TIMES("OfflinePages.Model.ConstructionToLoadedEventTime",
                       base::TimeTicks::Now() - start_time);
 
-  // Create Storage Manager.
-  storage_manager_.reset(new OfflinePageStorageManager(
-      this, GetPolicyController(), archive_manager_.get()));
+  CacheLoadedData(offline_pages);
+  CompleteLoad();
 
-  // Run all the delayed tasks.
-  for (const auto& delayed_task : delayed_tasks_)
-    delayed_task.Run();
-  delayed_tasks_.clear();
-
-  for (Observer& observer : observers_)
-    observer.OfflinePageModelLoaded(this);
-
+  // Ensure necessary cleanup operations are started.
   CheckMetadataConsistency();
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(

[fgorski, 2016/11/14 21:59:47]

Move to CompleteLoad, as we want to clear storage even when the store load was
unsuccessful.

[fgorski, 2016/11/14 22:24:09]

Done.

       FROM_HERE, base::Bind(&OfflinePageModelImpl::ClearStorageIfNeeded,
                             weak_ptr_factory_.GetWeakPtr(),
                             base::Bind(&OfflinePageModelImpl::OnStorageCleared,
                                        weak_ptr_factory_.GetWeakPtr())),
       kStorageManagerStartingDelay);
 }
 
+void OfflinePageModelImpl::CompleteLoad() {
+  is_loaded_ = true;
+
+  // Inform observers the load is done.
+  for (Observer& observer : observers_)
+    observer.OfflinePageModelLoaded(this);
+
+  // Run all the delayed tasks.
+  for (const auto& delayed_task : delayed_tasks_)
+    delayed_task.Run();
+  delayed_tasks_.clear();
+}
+
 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 173 matching lines @@
                         success);
 }
 
 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(

[fgorski, 2016/11/14 21:59:47]

make this method call itself.

[fgorski, 2016/11/14 22:24:10]

Done through Post...Task method instead.
Intention was to either run now or post delayed, but we already had a necessary
method for that.

     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,
                                             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",
@@ skipping 22 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