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

components/offline_pages/offline_page_metadata_store_impl_unittest.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_metadata_store.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 212 matching lines @@
     PumpLoop();
   }
 
   std::unique_ptr<OfflinePageMetadataStore> BuildStore();
   std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM52();
   std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM53();
   std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM54();
 
   void PumpLoop();
 
+  void InitializeCallback(StoreState state);
   void GetOfflinePagesCallback(
-      OfflinePageMetadataStore::LoadStatus load_status,
       const std::vector<OfflinePageItem>& offline_pages);
   void AddCallback(ItemActionStatus status);
   void UpdateCallback(CalledCallback called_callback,
                       std::unique_ptr<OfflinePagesUpdateResult> result);
-  void ResetCallback(bool status);
+  void ResetCallback(StoreState state);
 
   void ClearResults();
 
   OfflinePageItem CheckThatStoreHasOneItem();
   void CheckThatOfflinePageCanBeSaved(
       std::unique_ptr<OfflinePageMetadataStore> store);
 
   OfflinePagesUpdateResult* last_update_result() {
     return last_update_result_.get();
   }
@@ skipping 17 matching lines @@
       task_runner_handle_(task_runner_) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
 }
 
 OfflinePageMetadataStoreTest::~OfflinePageMetadataStoreTest() {}
 
 void OfflinePageMetadataStoreTest::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
+void OfflinePageMetadataStoreTest::InitializeCallback(StoreState state) {
+  last_status_ = state == StoreState::LOADED ? STATUS_TRUE : STATUS_FALSE;
+}
+
 void OfflinePageMetadataStoreTest::GetOfflinePagesCallback(
-    OfflinePageMetadataStore::LoadStatus load_status,
     const std::vector<OfflinePageItem>& offline_pages) {
   last_called_callback_ = LOAD;
-  last_status_ = load_status == OfflinePageMetadataStore::LOAD_SUCCEEDED ?
-      STATUS_TRUE : STATUS_FALSE;
   offline_pages_.swap(const_cast<std::vector<OfflinePageItem>&>(offline_pages));
 }
 
 void OfflinePageMetadataStoreTest::AddCallback(ItemActionStatus status) {
   last_called_callback_ = ADD;
   // TODO(fgorski): Add specific add status.
   // last_item_status_ = status;
   last_status_ =
       status == ItemActionStatus::SUCCESS ? STATUS_TRUE : STATUS_FALSE;
 }
 
 void OfflinePageMetadataStoreTest::UpdateCallback(
     CalledCallback called_callback,
     std::unique_ptr<OfflinePagesUpdateResult> result) {
   last_called_callback_ = called_callback;
   last_status_ = result->updated_items.size() > 0 ? STATUS_TRUE : STATUS_FALSE;
   last_update_result_ = std::move(result);
 }
 
-void OfflinePageMetadataStoreTest::ResetCallback(bool status) {
+void OfflinePageMetadataStoreTest::ResetCallback(StoreState state) {
   last_called_callback_ = RESET;
-  last_status_ = status ? STATUS_TRUE : STATUS_FALSE;
+  last_status_ = state == StoreState::LOADED ? STATUS_TRUE : STATUS_FALSE;
 }
 
 void OfflinePageMetadataStoreTest::ClearResults() {
   last_called_callback_ = NONE;
   last_status_ = STATUS_NONE;
   offline_pages_.clear();
   last_update_result_.reset(nullptr);
 }
 
 OfflinePageItem OfflinePageMetadataStoreTest::CheckThatStoreHasOneItem() {
@@ skipping 34 matching lines @@
     std::swap(offline_pages_[0], offline_pages_[1]);
   }
   EXPECT_EQ(offline_page, offline_pages_[0]);
 }
 
 std::unique_ptr<OfflinePageMetadataStore>
 OfflinePageMetadataStoreTest::BuildStore() {
   std::unique_ptr<OfflinePageMetadataStore> store(
       factory_.BuildStore(temp_directory_.GetPath()));
   PumpLoop();
+  store->Initialize(
+      base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback,
+                 base::Unretained(this)));
+  PumpLoop();
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   return store;
 }
 
 std::unique_ptr<OfflinePageMetadataStore>
 OfflinePageMetadataStoreTest::BuildStoreWithSchemaFromM52() {
   std::unique_ptr<OfflinePageMetadataStore> store(
       factory_.BuildStoreM52(temp_directory_.GetPath()));
   PumpLoop();
+  store->Initialize(
+      base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback,
+                 base::Unretained(this)));
+  PumpLoop();
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   return store;
 }
 
 std::unique_ptr<OfflinePageMetadataStore>
 OfflinePageMetadataStoreTest::BuildStoreWithSchemaFromM53() {
   std::unique_ptr<OfflinePageMetadataStore> store(
       factory_.BuildStoreM53(temp_directory_.GetPath()));
   PumpLoop();
+  store->Initialize(
+      base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback,
+                 base::Unretained(this)));
+  PumpLoop();
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   return store;
 }
 
 std::unique_ptr<OfflinePageMetadataStore>
 OfflinePageMetadataStoreTest::BuildStoreWithSchemaFromM54() {
   std::unique_ptr<OfflinePageMetadataStore> store(
       factory_.BuildStoreM53(temp_directory_.GetPath()));
   PumpLoop();
+  store->Initialize(
+      base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback,
+                 base::Unretained(this)));
+  PumpLoop();
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   return store;
 }
 
 // Loads empty store and makes sure that there are no offline pages stored in
 // it.
 TEST_F(OfflinePageMetadataStoreTest, LoadEmptyStore) {
   std::unique_ptr<OfflinePageMetadataStore> store(BuildStore());
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
   EXPECT_EQ(0U, offline_pages_.size());
 }
 
 TEST_F(OfflinePageMetadataStoreTest, GetOfflinePagesFromInvalidStore) {
   std::unique_ptr<OfflinePageMetadataStore> store(BuildStore());
   OfflinePageMetadataStoreSQL* sql_store =
       static_cast<OfflinePageMetadataStoreSQL*>(store.get());
 
   sql_store->SetStateForTesting(StoreState::NOT_LOADED, false);
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(0UL, offline_pages_.size());
-  EXPECT_EQ(STATUS_FALSE, last_status_);
+  EXPECT_EQ(StoreState::NOT_LOADED, store->state());
 
+  ClearResults();
   sql_store->SetStateForTesting(StoreState::FAILED_LOADING, false);
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(0UL, offline_pages_.size());
-  EXPECT_EQ(STATUS_FALSE, last_status_);
+  EXPECT_EQ(StoreState::FAILED_LOADING, store->state());
 
+  ClearResults();
   sql_store->SetStateForTesting(StoreState::FAILED_RESET, false);
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(0UL, offline_pages_.size());
-  EXPECT_EQ(STATUS_FALSE, last_status_);
+  EXPECT_EQ(StoreState::FAILED_RESET, store->state());
 
+  ClearResults();
   sql_store->SetStateForTesting(StoreState::LOADED, true);
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(0UL, offline_pages_.size());
-  EXPECT_EQ(STATUS_FALSE, last_status_);
 
+  ClearResults();
   sql_store->SetStateForTesting(StoreState::NOT_LOADED, true);
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(0UL, offline_pages_.size());
-  EXPECT_EQ(STATUS_FALSE, last_status_);
 
+  ClearResults();
   sql_store->SetStateForTesting(StoreState::FAILED_LOADING, false);
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(0UL, offline_pages_.size());
-  EXPECT_EQ(STATUS_FALSE, last_status_);
 
+  ClearResults();
   sql_store->SetStateForTesting(StoreState::FAILED_RESET, false);
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(0UL, offline_pages_.size());
-  EXPECT_EQ(STATUS_FALSE, last_status_);
-
 }
 
 // Loads a store which has an outdated schema.
 // This test case would crash if it's not handling correctly when we're loading
 // old version stores.
 // TODO(romax): Move this to sql_unittest.
 TEST_F(OfflinePageMetadataStoreTest, LoadVersion52Store) {
   std::unique_ptr<OfflinePageMetadataStore> store(
       BuildStoreWithSchemaFromM52());
 
@@ skipping 71 matching lines @@
                                base::FilePath(kFilePath), kFileSize);
   store->AddOfflinePage(offline_page,
                         base::Bind(&OfflinePageMetadataStoreTest::AddCallback,
                                    base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
 
-  // Load the store.
+  // Get all pages from the store.
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(1U, offline_pages_.size());
 
   // Remove the offline page.
   std::vector<int64_t> ids_to_remove;
   ids_to_remove.push_back(offline_page.offline_id);
   store->RemoveOfflinePages(
       ids_to_remove, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
                                 base::Unretained(this), REMOVE));
   PumpLoop();
   EXPECT_EQ(REMOVE, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
   ASSERT_TRUE(last_update_result() != nullptr);
   EXPECT_EQ(1UL, last_update_result()->item_statuses.size());
   EXPECT_EQ(ItemActionStatus::SUCCESS,
             last_update_result()->item_statuses.begin()->second);
   EXPECT_EQ(1UL, last_update_result()->updated_items.size());
   EXPECT_EQ(offline_page, *(last_update_result()->updated_items.begin()));
 
   ClearResults();
 
-  // Load the store.
+  // Get all pages from the store.
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(LOAD, last_called_callback_);
   EXPECT_EQ(0U, offline_pages_.size());
 
   ClearResults();
 
   // Close and reload the store.
@@ skipping 29 matching lines @@
   // Add anther offline page.
   store->AddOfflinePage(offline_page_2,
                         base::Bind(&OfflinePageMetadataStoreTest::AddCallback,
                                    base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
 
-  // Load the store.
+  // Get all pages from the store.
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
 
   EXPECT_EQ(LOAD, last_called_callback_);
-  EXPECT_EQ(STATUS_TRUE, last_status_);
   EXPECT_EQ(2U, offline_pages_.size());
 
   // Remove the offline page.
   std::vector<int64_t> ids_to_remove;
   ids_to_remove.push_back(offline_page_1.offline_id);
   store->RemoveOfflinePages(
       ids_to_remove, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
                                 base::Unretained(this), REMOVE));
   PumpLoop();
   EXPECT_EQ(REMOVE, last_called_callback_);
@@ skipping 44 matching lines @@
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
 
   EXPECT_EQ(LOAD, last_called_callback_);
-  EXPECT_EQ(STATUS_TRUE, last_status_);
   ASSERT_EQ(1U, offline_pages_.size());
   EXPECT_EQ(offline_page, offline_pages_[0]);
 
   // Then update some data.
   offline_page.file_size = kFileSize + 1;
   offline_page.access_count++;
   offline_page.expiration_time = base::Time::Now();
   std::vector<OfflinePageItem> items_to_update;
   items_to_update.push_back(offline_page);
   store->UpdateOfflinePages(
       items_to_update, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
                                   base::Unretained(this), UPDATE));
   PumpLoop();
   EXPECT_EQ(UPDATE, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
   ASSERT_TRUE(last_update_result() != nullptr);
   EXPECT_EQ(1UL, last_update_result()->item_statuses.size());
   EXPECT_EQ(ItemActionStatus::SUCCESS,
             last_update_result()->item_statuses.begin()->second);
   EXPECT_EQ(1UL, last_update_result()->updated_items.size());
   EXPECT_EQ(offline_page, *(last_update_result()->updated_items.begin()));
 
   ClearResults();
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
 
   EXPECT_EQ(LOAD, last_called_callback_);
-  EXPECT_EQ(STATUS_TRUE, last_status_);
   ASSERT_EQ(1U, offline_pages_.size());
   EXPECT_EQ(offline_page, offline_pages_[0]);
 }
 
 TEST_F(OfflinePageMetadataStoreTest, ClearAllOfflinePages) {
   std::unique_ptr<OfflinePageMetadataStore> store(BuildStore());
 
   // Add 2 offline pages.
   OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1,
                                base::FilePath(kFilePath), kFileSize);
@@ skipping 10 matching lines @@
                                 base::FilePath(kFilePath), kFileSize);
   store->AddOfflinePage(offline_page2,
                         base::Bind(&OfflinePageMetadataStoreTest::AddCallback,
                                    base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
 
-  // Load the store.
+  // Get all pages from the store.
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
 
   EXPECT_EQ(LOAD, last_called_callback_);
-  EXPECT_EQ(STATUS_TRUE, last_status_);
   EXPECT_EQ(2U, offline_pages_.size());
 
   // Clear all records from the store.
   store->Reset(base::Bind(&OfflinePageMetadataStoreTest::ResetCallback,
                           base::Unretained(this)));
   PumpLoop();
   EXPECT_EQ(RESET, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
-  // Load the store.
+  ClearResults();
+
+  // Get all pages from the store.
   store->GetOfflinePages(
       base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback,
                  base::Unretained(this)));
   PumpLoop();
 
   EXPECT_EQ(LOAD, last_called_callback_);
-  EXPECT_EQ(STATUS_TRUE, last_status_);
   ASSERT_EQ(0U, offline_pages_.size());
 }
 
 }  // namespace
 }  // namespace offline_pages