[Offline pages] OPM SQL store: moving load to constructor, updating read to GetOfflinePages

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 112 matching lines @@
   statement.BindCString(8, kTestURL);
   statement.BindString(9, base::FilePath(kFilePath).MaybeAsASCII());
   statement.BindInt64(10, base::Time::Now().ToInternalValue());
   ASSERT_TRUE(statement.Run());
   ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1));
   ASSERT_FALSE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "title"));
 }
 
 class OfflinePageMetadataStoreFactory {
  public:
-  OfflinePageMetadataStore* BuildStore(const base::FilePath& file) {
+  OfflinePageMetadataStore* BuildStore(const base::FilePath& file_path) {
     OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL(
-        base::ThreadTaskRunnerHandle::Get(), file);
+        base::ThreadTaskRunnerHandle::Get(), file_path);
     return store;
   }
 
-  OfflinePageMetadataStore* BuildStoreM52(const base::FilePath& file) {
-    BuildTestStoreWithSchemaFromM52(file);
+  OfflinePageMetadataStore* BuildStoreM52(const base::FilePath& file_path) {
+    BuildTestStoreWithSchemaFromM52(file_path);
     OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL(
-        base::ThreadTaskRunnerHandle::Get(), file);
+        base::ThreadTaskRunnerHandle::Get(), file_path);
     return store;
   }
 
-  OfflinePageMetadataStore* BuildStoreM53(const base::FilePath& file) {
-    BuildTestStoreWithSchemaFromM53(file);
+  OfflinePageMetadataStore* BuildStoreM53(const base::FilePath& file_path) {
+    BuildTestStoreWithSchemaFromM53(file_path);
     OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL(
-        base::ThreadTaskRunnerHandle::Get(), file);
+        base::ThreadTaskRunnerHandle::Get(), file_path);
     return store;
   }
 };
 
 enum CalledCallback { NONE, LOAD, ADD, REMOVE, RESET };
 enum Status { STATUS_NONE, STATUS_TRUE, STATUS_FALSE };
 
 class OfflinePageMetadataStoreTest : public testing::Test {
  public:
   OfflinePageMetadataStoreTest();
   ~OfflinePageMetadataStoreTest() override;
 
   void TearDown() override {
     // Wait for all the pieces of the store to delete itself properly.
     PumpLoop();
   }
 
   std::unique_ptr<OfflinePageMetadataStore> BuildStore();
   std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM52();
   std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM53();
 
   void PumpLoop();
 
-  void LoadCallback(OfflinePageMetadataStore::LoadStatus load_status,
-                    const std::vector<OfflinePageItem>& offline_pages);
+  void GetOfflinePagesCallback(
+      OfflinePageMetadataStore::LoadStatus load_status,
+      const std::vector<OfflinePageItem>& offline_pages);
   void UpdateCallback(CalledCallback called_callback, bool success);
 
   void ClearResults();
 
   OfflinePageItem CheckThatStoreHasOneItem();
   void CheckThatOfflinePageCanBeSaved(
       std::unique_ptr<OfflinePageMetadataStore> store);
 
  protected:
   CalledCallback last_called_callback_;
@@ skipping 13 matching lines @@
       task_runner_handle_(task_runner_) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
 }
 
 OfflinePageMetadataStoreTest::~OfflinePageMetadataStoreTest() {}
 
 void OfflinePageMetadataStoreTest::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
-void OfflinePageMetadataStoreTest::LoadCallback(
+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::UpdateCallback(
     CalledCallback called_callback,
@@ skipping 54 matching lines @@
   EXPECT_EQ(offline_page.client_id, offline_pages_[0].client_id);
   EXPECT_EQ(1234LL, offline_pages_[0].offline_id);
   EXPECT_EQ(kFileSize, offline_pages_[0].file_size);
   EXPECT_EQ(kTestClientId1, offline_pages_[0].client_id);
 }
 
 std::unique_ptr<OfflinePageMetadataStore>
 OfflinePageMetadataStoreTest::BuildStore() {
   std::unique_ptr<OfflinePageMetadataStore> store(
       factory_.BuildStore(temp_directory_.path()));
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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_.path()));
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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_.path()));
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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_);
@@ skipping 45 matching lines @@
   store->AddOrUpdateOfflinePage(
       offline_page, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
                                base::Unretained(this), ADD));
   PumpLoop();
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
 
   // Load the store.
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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_);
 
   ClearResults();
 
   // Load the store.
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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.
   store.reset();
   store = BuildStore();
   EXPECT_EQ(LOAD, last_called_callback_);
@@ skipping 27 matching lines @@
   store->AddOrUpdateOfflinePage(
       offline_page_2, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
                                  base::Unretained(this), ADD));
   PumpLoop();
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
 
   // Load the store.
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
 
   // Close and reload the store.
   store.reset();
   store = BuildStore();
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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_2.url, offline_pages_[0].url);
   EXPECT_EQ(offline_page_2.offline_id, offline_pages_[0].offline_id);
   EXPECT_EQ(offline_page_2.version, offline_pages_[0].version);
   EXPECT_EQ(offline_page_2.file_path, offline_pages_[0].file_path);
   EXPECT_EQ(offline_page_2.file_size, offline_pages_[0].file_size);
@@ skipping 13 matching lines @@
   OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1,
                                base::FilePath(kFilePath), kFileSize);
   store->AddOrUpdateOfflinePage(
       offline_page, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
                                base::Unretained(this), ADD));
   PumpLoop();
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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.url, offline_pages_[0].url);
   EXPECT_EQ(offline_page.offline_id, offline_pages_[0].offline_id);
   EXPECT_EQ(offline_page.version, offline_pages_[0].version);
   EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path);
   EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size);
   EXPECT_EQ(offline_page.creation_time, offline_pages_[0].creation_time);
   EXPECT_EQ(offline_page.last_access_time, offline_pages_[0].last_access_time);
   EXPECT_EQ(offline_page.expiration_time, offline_pages_[0].expiration_time);
   EXPECT_EQ(offline_page.access_count, offline_pages_[0].access_count);
   EXPECT_EQ(offline_page.client_id, offline_pages_[0].client_id);
 
   // Then update some data.
   offline_page.file_size = kFileSize + 1;
   offline_page.access_count++;
   offline_page.expiration_time = base::Time::Now();
   store->AddOrUpdateOfflinePage(
       offline_page, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
                                base::Unretained(this), ADD));
   PumpLoop();
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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.url, offline_pages_[0].url);
   EXPECT_EQ(offline_page.offline_id, offline_pages_[0].offline_id);
   EXPECT_EQ(offline_page.version, offline_pages_[0].version);
   EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path);
   EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size);
@@ skipping 24 matching lines @@
   store->AddOrUpdateOfflinePage(
       offline_page2, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback,
                                 base::Unretained(this), ADD));
   PumpLoop();
   EXPECT_EQ(ADD, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   ClearResults();
 
   // Load the store.
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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::UpdateCallback,
                           base::Unretained(this), RESET));
   PumpLoop();
   EXPECT_EQ(RESET, last_called_callback_);
   EXPECT_EQ(STATUS_TRUE, last_status_);
 
   // Load the store.
-  store->Load(base::Bind(&OfflinePageMetadataStoreTest::LoadCallback,
-                         base::Unretained(this)));
+  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