[Offline pages] Preventing GetPagesMatchingQuery from running before model is loaded

components/offline_pages/offline_page_model_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_model_impl.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 464 matching lines @@
     if (page.client_id.name_space == name_space)
       return true;
   }
 
   return false;
 }
 
 TEST_F(OfflinePageModelImplTest, SavePageSuccessful) {
   EXPECT_FALSE(HasPages(kTestClientNamespace));
 
-   std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
+  std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
       kTestUrl, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
   SavePageWithArchiverAsync(
       kTestUrl, kTestClientId1, kTestUrl2, std::move(archiver));
   PumpLoop();
   EXPECT_TRUE(HasPages(kTestClientNamespace));
 
   OfflinePageTestStore* store = GetStore();
   EXPECT_EQ(kTestUrl, store->last_saved_page().url);
   EXPECT_EQ(kTestClientId1.id, store->last_saved_page().client_id.id);
   EXPECT_EQ(kTestClientId1.name_space,
@@ skipping 768 matching lines @@
   EXPECT_EQ(StoreState::FAILED_RESET, GetStore()->state());
   EXPECT_EQ(0UL, offline_pages.size());
 
   ResetResults();
   std::pair<SavePageResult, int64_t> result =
       SavePage(kTestUrl, ClientId(kDownloadNamespace, "123"));
 
   EXPECT_EQ(SavePageResult::STORE_FAILURE, result.first);
 }
 
+TEST_F(OfflinePageModelImplTest, GetPagesMatchingQuery) {
+  std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
+      kTestUrl, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
+  SavePageWithArchiverAsync(kTestUrl, kTestClientId1, kTestUrl2,
+                            std::move(archiver));
+  PumpLoop();
+
+  std::vector<ClientId> client_ids{kTestClientId1};
+  OfflinePageModelQueryBuilder builder;
+  builder.SetClientIds(OfflinePageModelQuery::Requirement::INCLUDE_MATCHING,
+                       client_ids);
+
+  MultipleOfflinePageItemResult offline_pages;
+  model()->GetPagesMatchingQuery(
+      builder.Build(model()->GetPolicyController()),
+      base::Bind(&OfflinePageModelImplTest::OnGetMultipleOfflinePageItemsResult,
+                 AsWeakPtr(), base::Unretained(&offline_pages)));
+  PumpLoop();
+
+  ASSERT_EQ(1UL, offline_pages.size());
+  EXPECT_EQ(kTestUrl, offline_pages[0].url);
+  EXPECT_EQ(kTestClientId1.id, offline_pages[0].client_id.id);
+  EXPECT_EQ(kTestClientId1.name_space, offline_pages[0].client_id.name_space);
+  EXPECT_EQ(last_archiver_path(), offline_pages[0].file_path);
+  EXPECT_EQ(kTestFileSize, offline_pages[0].file_size);
+  EXPECT_EQ(0, offline_pages[0].access_count);
+  EXPECT_EQ(0, offline_pages[0].flags);
+  EXPECT_EQ(kTestTitle, offline_pages[0].title);
+  EXPECT_EQ(kTestUrl2, offline_pages[0].original_url);
+}
+
 TEST(CommandLineFlagsTest, OfflineBookmarks) {
   // Disabled by default.
   EXPECT_FALSE(offline_pages::IsOfflineBookmarksEnabled());
 
   // Check if feature is correctly enabled by command-line flag.
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(kOfflineBookmarksFeature);
   EXPECT_TRUE(offline_pages::IsOfflineBookmarksEnabled());
 }
 
@@ skipping 40 matching lines @@
   EXPECT_FALSE(offline_pages::IsOfflinePagesSvelteConcurrentLoadingEnabled());
 
   // Check if feature is correctly enabled by command-line flag.
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       kOfflinePagesSvelteConcurrentLoadingFeature);
   EXPECT_TRUE(offline_pages::IsOfflinePagesSvelteConcurrentLoadingEnabled());
 }
 
 }  // namespace offline_pages