| // 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/core/offline_page_metadata_store.h" |
| |
| #include <stdint.h> |
| |
| #include <memory> |
| |
| #include "base/bind.h" |
| #include "base/files/file_path.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/test/bind_test_util.h" |
| #include "base/test/test_mock_time_task_runner.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "components/offline_pages/core/client_namespace_constants.h" |
| #include "components/offline_pages/core/model/offline_page_item_generator.h" |
| #include "components/offline_pages/core/offline_clock.h" |
| #include "components/offline_pages/core/offline_page_item.h" |
| #include "components/offline_pages/core/offline_page_metadata_store.h" |
| #include "components/offline_pages/core/offline_page_model.h" |
| #include "components/offline_pages/core/offline_page_thumbnail.h" |
| #include "components/offline_pages/core/offline_store_utils.h" |
| #include "sql/database.h" |
| #include "sql/meta_table.h" |
| #include "sql/statement.h" |
| #include "sql/transaction.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace offline_pages { |
| |
| namespace { |
| |
| #define OFFLINE_PAGES_TABLE_V1 "offlinepages_v1" |
| |
| const char kTestClientNamespace[] = "CLIENT_NAMESPACE"; |
| const char kTestURL[] = "https://example.com"; |
| const char kOriginalTestURL[] = "https://example.com/foo"; |
| const ClientId kTestClientId1(kTestClientNamespace, "1234"); |
| const ClientId kTestClientId2(kTestClientNamespace, "5678"); |
| const base::FilePath::CharType kFilePath[] = |
| FILE_PATH_LITERAL("/offline_pages/example_com.mhtml"); |
| int64_t kFileSize = 234567LL; |
| int64_t kOfflineId = 12345LL; |
| const char kTestRequestOrigin[] = "request.origin"; |
| int64_t kTestSystemDownloadId = 42LL; |
| const char kTestDigest[] = "test-digest"; |
| const base::Time kThumbnailExpiration = store_utils::FromDatabaseTime(42); |
| |
| // Build a store with outdated schema to simulate the upgrading process. |
| void BuildTestStoreWithSchemaFromM52(const base::FilePath& file) { |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id INTEGER PRIMARY KEY NOT NULL, " |
| "creation_time INTEGER NOT NULL, " |
| "file_size INTEGER NOT NULL, " |
| "version INTEGER NOT NULL, " |
| "last_access_time INTEGER NOT NULL, " |
| "access_count INTEGER NOT NULL, " |
| "status INTEGER NOT NULL DEFAULT 0, " |
| "user_initiated INTEGER, " |
| "client_namespace VARCHAR NOT NULL, " |
| "client_id VARCHAR NOT NULL, " |
| "online_url VARCHAR NOT NULL, " |
| "offline_url VARCHAR NOT NULL DEFAULT '', " |
| "file_path VARCHAR NOT NULL " |
| ")")); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| sql::Statement statement(connection.GetUniqueStatement( |
| "INSERT INTO " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id, creation_time, file_size, version, " |
| "last_access_time, access_count, client_namespace, " |
| "client_id, online_url, file_path) " |
| "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); |
| statement.BindInt64(0, kOfflineId); |
| statement.BindInt(1, 0); |
| statement.BindInt64(2, kFileSize); |
| statement.BindInt(3, 0); |
| statement.BindInt(4, 0); |
| statement.BindInt(5, 1); |
| statement.BindCString(6, kTestClientNamespace); |
| statement.BindString(7, kTestClientId2.id); |
| statement.BindCString(8, kTestURL); |
| statement.BindString(9, base::FilePath(kFilePath).MaybeAsASCII()); |
| ASSERT_TRUE(statement.Run()); |
| ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); |
| ASSERT_FALSE( |
| connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "expiration_time")); |
| } |
| |
| void BuildTestStoreWithSchemaFromM53(const base::FilePath& file) { |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id INTEGER PRIMARY KEY NOT NULL, " |
| "creation_time INTEGER NOT NULL, " |
| "file_size INTEGER NOT NULL, " |
| "version INTEGER NOT NULL, " |
| "last_access_time INTEGER NOT NULL, " |
| "access_count INTEGER NOT NULL, " |
| "status INTEGER NOT NULL DEFAULT 0, " |
| "user_initiated INTEGER, " |
| "expiration_time INTEGER NOT NULL DEFAULT 0, " |
| "client_namespace VARCHAR NOT NULL, " |
| "client_id VARCHAR NOT NULL, " |
| "online_url VARCHAR NOT NULL, " |
| "offline_url VARCHAR NOT NULL DEFAULT '', " |
| "file_path VARCHAR NOT NULL " |
| ")")); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| sql::Statement statement(connection.GetUniqueStatement( |
| "INSERT INTO " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id, creation_time, file_size, version, " |
| "last_access_time, access_count, client_namespace, " |
| "client_id, online_url, file_path, expiration_time) " |
| "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); |
| statement.BindInt64(0, kOfflineId); |
| statement.BindInt(1, 0); |
| statement.BindInt64(2, kFileSize); |
| statement.BindInt(3, 0); |
| statement.BindInt(4, 0); |
| statement.BindInt(5, 1); |
| statement.BindCString(6, kTestClientNamespace); |
| statement.BindString(7, kTestClientId2.id); |
| statement.BindCString(8, kTestURL); |
| statement.BindString(9, base::FilePath(kFilePath).MaybeAsASCII()); |
| statement.BindInt64(10, store_utils::ToDatabaseTime(OfflineTimeNow())); |
| ASSERT_TRUE(statement.Run()); |
| ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); |
| ASSERT_FALSE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "title")); |
| } |
| |
| void BuildTestStoreWithSchemaFromM54(const base::FilePath& file) { |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id INTEGER PRIMARY KEY NOT NULL, " |
| "creation_time INTEGER NOT NULL, " |
| "file_size INTEGER NOT NULL, " |
| "version INTEGER NOT NULL, " |
| "last_access_time INTEGER NOT NULL, " |
| "access_count INTEGER NOT NULL, " |
| "status INTEGER NOT NULL DEFAULT 0, " |
| "user_initiated INTEGER, " |
| "expiration_time INTEGER NOT NULL DEFAULT 0, " |
| "client_namespace VARCHAR NOT NULL, " |
| "client_id VARCHAR NOT NULL, " |
| "online_url VARCHAR NOT NULL, " |
| "offline_url VARCHAR NOT NULL DEFAULT '', " |
| "file_path VARCHAR NOT NULL, " |
| "title VARCHAR NOT NULL DEFAULT ''" |
| ")")); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| sql::Statement statement(connection.GetUniqueStatement( |
| "INSERT INTO " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id, creation_time, file_size, version, " |
| "last_access_time, access_count, client_namespace, " |
| "client_id, online_url, file_path, expiration_time, title) " |
| "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); |
| statement.BindInt64(0, kOfflineId); |
| statement.BindInt(1, 0); |
| statement.BindInt64(2, kFileSize); |
| statement.BindInt(3, 0); |
| statement.BindInt(4, 0); |
| statement.BindInt(5, 1); |
| statement.BindCString(6, kTestClientNamespace); |
| statement.BindString(7, kTestClientId2.id); |
| statement.BindCString(8, kTestURL); |
| statement.BindString(9, base::FilePath(kFilePath).MaybeAsASCII()); |
| statement.BindInt64(10, store_utils::ToDatabaseTime(OfflineTimeNow())); |
| statement.BindString16(11, base::UTF8ToUTF16("Test title")); |
| ASSERT_TRUE(statement.Run()); |
| ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); |
| ASSERT_TRUE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "version")); |
| ASSERT_TRUE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "status")); |
| ASSERT_TRUE( |
| connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "user_initiated")); |
| ASSERT_TRUE( |
| connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "offline_url")); |
| } |
| |
| void BuildTestStoreWithSchemaFromM55(const base::FilePath& file) { |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id INTEGER PRIMARY KEY NOT NULL, " |
| "creation_time INTEGER NOT NULL, " |
| "file_size INTEGER NOT NULL, " |
| "last_access_time INTEGER NOT NULL, " |
| "access_count INTEGER NOT NULL, " |
| "expiration_time INTEGER NOT NULL DEFAULT 0, " |
| "client_namespace VARCHAR NOT NULL, " |
| "client_id VARCHAR NOT NULL, " |
| "online_url VARCHAR NOT NULL, " |
| "file_path VARCHAR NOT NULL, " |
| "title VARCHAR NOT NULL DEFAULT ''" |
| ")")); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| sql::Statement statement(connection.GetUniqueStatement( |
| "INSERT INTO " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id, creation_time, file_size, " |
| "last_access_time, access_count, client_namespace, " |
| "client_id, online_url, file_path, expiration_time, title) " |
| "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); |
| statement.BindInt64(0, kOfflineId); |
| statement.BindInt(1, 0); |
| statement.BindInt64(2, kFileSize); |
| statement.BindInt(3, 0); |
| statement.BindInt(4, 1); |
| statement.BindCString(5, kTestClientNamespace); |
| statement.BindString(6, kTestClientId2.id); |
| statement.BindCString(7, kTestURL); |
| statement.BindString(8, base::FilePath(kFilePath).MaybeAsASCII()); |
| statement.BindInt64(9, store_utils::ToDatabaseTime(OfflineTimeNow())); |
| statement.BindString16(10, base::UTF8ToUTF16("Test title")); |
| ASSERT_TRUE(statement.Run()); |
| ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); |
| ASSERT_TRUE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "title")); |
| ASSERT_FALSE( |
| connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "original_url")); |
| } |
| |
| void BuildTestStoreWithSchemaFromM56(const base::FilePath& file) { |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id INTEGER PRIMARY KEY NOT NULL, " |
| "creation_time INTEGER NOT NULL, " |
| "file_size INTEGER NOT NULL, " |
| "last_access_time INTEGER NOT NULL, " |
| "access_count INTEGER NOT NULL, " |
| "expiration_time INTEGER NOT NULL DEFAULT 0, " |
| "client_namespace VARCHAR NOT NULL, " |
| "client_id VARCHAR NOT NULL, " |
| "online_url VARCHAR NOT NULL, " |
| "file_path VARCHAR NOT NULL, " |
| "title VARCHAR NOT NULL DEFAULT '', " |
| "original_url VARCHAR NOT NULL DEFAULT ''" |
| ")")); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| sql::Statement statement(connection.GetUniqueStatement( |
| "INSERT INTO " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id, creation_time, file_size, " |
| "last_access_time, access_count, client_namespace, " |
| "client_id, online_url, file_path, expiration_time, title, original_url) " |
| "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); |
| statement.BindInt64(0, kOfflineId); |
| statement.BindInt(1, 0); |
| statement.BindInt64(2, kFileSize); |
| statement.BindInt(3, 0); |
| statement.BindInt(4, 1); |
| statement.BindCString(5, kTestClientNamespace); |
| statement.BindString(6, kTestClientId2.id); |
| statement.BindCString(7, kTestURL); |
| statement.BindString(8, base::FilePath(kFilePath).MaybeAsASCII()); |
| statement.BindInt64(9, store_utils::ToDatabaseTime(OfflineTimeNow())); |
| statement.BindString16(10, base::UTF8ToUTF16("Test title")); |
| statement.BindCString(11, kOriginalTestURL); |
| ASSERT_TRUE(statement.Run()); |
| ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); |
| ASSERT_TRUE( |
| connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "expiration_time")); |
| } |
| |
| void BuildTestStoreWithSchemaFromM57(const base::FilePath& file) { |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id INTEGER PRIMARY KEY NOT NULL," |
| " creation_time INTEGER NOT NULL," |
| " file_size INTEGER NOT NULL," |
| " last_access_time INTEGER NOT NULL," |
| " access_count INTEGER NOT NULL," |
| " client_namespace VARCHAR NOT NULL," |
| " client_id VARCHAR NOT NULL," |
| " online_url VARCHAR NOT NULL," |
| " file_path VARCHAR NOT NULL," |
| " title VARCHAR NOT NULL DEFAULT ''," |
| " original_url VARCHAR NOT NULL DEFAULT ''" |
| ")")); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| sql::Statement statement(connection.GetUniqueStatement( |
| "INSERT INTO " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id, creation_time, file_size, " |
| "last_access_time, access_count, client_namespace, " |
| "client_id, online_url, file_path, title, original_url) " |
| "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); |
| statement.BindInt64(0, kOfflineId); |
| statement.BindInt(1, 0); |
| statement.BindInt64(2, kFileSize); |
| statement.BindInt(3, 0); |
| statement.BindInt(4, 1); |
| statement.BindCString(5, kTestClientNamespace); |
| statement.BindString(6, kTestClientId2.id); |
| statement.BindCString(7, kTestURL); |
| statement.BindString(8, base::FilePath(kFilePath).MaybeAsASCII()); |
| statement.BindString16(9, base::UTF8ToUTF16("Test title")); |
| statement.BindCString(10, kOriginalTestURL); |
| ASSERT_TRUE(statement.Run()); |
| ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); |
| ASSERT_FALSE( |
| connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "request_origin")); |
| } |
| |
| void BuildTestStoreWithSchemaFromM61(const base::FilePath& file) { |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id INTEGER PRIMARY KEY NOT NULL," |
| " creation_time INTEGER NOT NULL," |
| " file_size INTEGER NOT NULL," |
| " last_access_time INTEGER NOT NULL," |
| " access_count INTEGER NOT NULL," |
| " client_namespace VARCHAR NOT NULL," |
| " client_id VARCHAR NOT NULL," |
| " online_url VARCHAR NOT NULL," |
| " file_path VARCHAR NOT NULL," |
| " title VARCHAR NOT NULL DEFAULT ''," |
| " original_url VARCHAR NOT NULL DEFAULT ''," |
| " request_origin VARCHAR NOT NULL DEFAULT ''" |
| ")")); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| sql::Statement statement(connection.GetUniqueStatement( |
| "INSERT INTO " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id, creation_time, file_size, " |
| "last_access_time, access_count, client_namespace, " |
| "client_id, online_url, file_path, title, original_url, " |
| "request_origin) " |
| "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); |
| statement.BindInt64(0, kOfflineId); |
| statement.BindInt(1, 0); |
| statement.BindInt64(2, kFileSize); |
| statement.BindInt(3, 0); |
| statement.BindInt(4, 1); |
| statement.BindCString(5, kTestClientNamespace); |
| statement.BindString(6, kTestClientId2.id); |
| statement.BindCString(7, kTestURL); |
| statement.BindString(8, base::FilePath(kFilePath).MaybeAsASCII()); |
| statement.BindString16(9, base::UTF8ToUTF16("Test title")); |
| statement.BindCString(10, kOriginalTestURL); |
| statement.BindString(11, kTestRequestOrigin); |
| ASSERT_TRUE(statement.Run()); |
| ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); |
| ASSERT_FALSE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "digest")); |
| } |
| |
| void InjectItemInM62Store(sql::Database* db, const OfflinePageItem& item) { |
| ASSERT_TRUE(db->BeginTransaction()); |
| sql::Statement statement(db->GetUniqueStatement( |
| "INSERT INTO " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id, creation_time, file_size, " |
| "last_access_time, access_count, client_namespace, " |
| "client_id, online_url, file_path, title, original_url, " |
| "request_origin, system_download_id, file_missing_time, " |
| "upgrade_attempt, digest) " |
| "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); |
| statement.BindInt64(0, item.offline_id); |
| statement.BindInt(1, store_utils::ToDatabaseTime(item.creation_time)); |
| statement.BindInt64(2, item.file_size); |
| statement.BindInt(3, store_utils::ToDatabaseTime(item.last_access_time)); |
| statement.BindInt(4, item.access_count); |
| statement.BindString(5, item.client_id.name_space); |
| statement.BindString(6, item.client_id.id); |
| statement.BindString(7, item.url.spec()); |
| statement.BindString(8, store_utils::ToDatabaseFilePath(item.file_path)); |
| statement.BindString16(9, item.title); |
| statement.BindString(10, item.original_url.spec()); |
| statement.BindString(11, item.request_origin); |
| statement.BindInt64(12, item.system_download_id); |
| statement.BindInt(13, store_utils::ToDatabaseTime(item.file_missing_time)); |
| statement.BindInt(14, item.upgrade_attempt); |
| statement.BindString(15, item.digest); |
| ASSERT_TRUE(statement.Run()); |
| ASSERT_TRUE(db->CommitTransaction()); |
| } |
| |
| void BuildTestStoreWithSchemaFromM62(const base::FilePath& file) { |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| ASSERT_TRUE( |
| connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 |
| "(offline_id INTEGER PRIMARY KEY NOT NULL," |
| " creation_time INTEGER NOT NULL," |
| " file_size INTEGER NOT NULL," |
| " last_access_time INTEGER NOT NULL," |
| " access_count INTEGER NOT NULL," |
| " system_download_id INTEGER NOT NULL DEFAULT 0," |
| " file_missing_time INTEGER NOT NULL DEFAULT 0," |
| " upgrade_attempt INTEGER NOT NULL DEFAULT 0," |
| " client_namespace VARCHAR NOT NULL," |
| " client_id VARCHAR NOT NULL," |
| " online_url VARCHAR NOT NULL," |
| " file_path VARCHAR NOT NULL," |
| " title VARCHAR NOT NULL DEFAULT ''," |
| " original_url VARCHAR NOT NULL DEFAULT ''," |
| " request_origin VARCHAR NOT NULL DEFAULT ''," |
| " digest VARCHAR NOT NULL DEFAULT ''" |
| ")")); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| |
| OfflinePageItemGenerator generator; |
| generator.SetNamespace(kTestClientNamespace); |
| generator.SetId(kTestClientId2.id); |
| generator.SetUrl(GURL(kTestURL)); |
| generator.SetRequestOrigin(kTestRequestOrigin); |
| generator.SetFileSize(kFileSize); |
| OfflinePageItem test_item = generator.CreateItem(); |
| test_item.offline_id = kOfflineId; |
| test_item.file_path = base::FilePath(kFilePath); |
| InjectItemInM62Store(&connection, test_item); |
| } |
| |
| void BuildTestStoreWithSchemaVersion1(const base::FilePath& file) { |
| BuildTestStoreWithSchemaFromM62(file); |
| sql::Database connection; |
| ASSERT_TRUE( |
| connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| ASSERT_TRUE(connection.BeginTransaction()); |
| sql::MetaTable meta_table; |
| ASSERT_TRUE(meta_table.Init(&connection, 1, 1)); |
| ASSERT_TRUE(connection.CommitTransaction()); |
| |
| OfflinePageItemGenerator generator; |
| generator.SetUrl(GURL(kTestURL)); |
| generator.SetRequestOrigin(kTestRequestOrigin); |
| generator.SetFileSize(kFileSize); |
| |
| generator.SetNamespace(kAsyncNamespace); |
| InjectItemInM62Store(&connection, generator.CreateItem()); |
| generator.SetNamespace(kDownloadNamespace); |
| InjectItemInM62Store(&connection, generator.CreateItem()); |
| generator.SetNamespace(kBrowserActionsNamespace); |
| InjectItemInM62Store(&connection, generator.CreateItem()); |
| generator.SetNamespace(kNTPSuggestionsNamespace); |
| InjectItemInM62Store(&connection, generator.CreateItem()); |
| } |
| |
| void BuildTestStoreWithSchemaVersion2(const base::FilePath& file) { |
| BuildTestStoreWithSchemaVersion1(file); |
| sql::Database db; |
| ASSERT_TRUE(db.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); |
| sql::MetaTable meta_table; |
| ASSERT_TRUE(meta_table.Init(&db, OfflinePageMetadataStore::kCurrentVersion, |
| OfflinePageMetadataStore::kCompatibleVersion)); |
| static const char kSql[] = |
| "CREATE TABLE page_thumbnails" |
| " (offline_id INTEGER PRIMARY KEY NOT NULL," |
| " expiration INTEGER NOT NULL," |
| " thumbnail BLOB NOT NULL" |
| ")"; |
| ASSERT_TRUE(db.Execute(kSql)); |
| } |
| |
| // Create an offline page item from a SQL result. Expects complete rows with |
| // all columns present. |
| OfflinePageItem MakeOfflinePageItem(sql::Statement* statement) { |
| int64_t id = statement->ColumnInt64(0); |
| base::Time creation_time = |
| store_utils::FromDatabaseTime(statement->ColumnInt64(1)); |
| int64_t file_size = statement->ColumnInt64(2); |
| base::Time last_access_time = |
| store_utils::FromDatabaseTime(statement->ColumnInt64(3)); |
| int access_count = statement->ColumnInt(4); |
| int64_t system_download_id = statement->ColumnInt64(5); |
| base::Time file_missing_time = |
| store_utils::FromDatabaseTime(statement->ColumnInt64(6)); |
| int upgrade_attempt = statement->ColumnInt(7); |
| ClientId client_id(statement->ColumnString(8), statement->ColumnString(9)); |
| GURL url(statement->ColumnString(10)); |
| base::FilePath path( |
| store_utils::FromDatabaseFilePath(statement->ColumnString(11))); |
| base::string16 title = statement->ColumnString16(12); |
| GURL original_url(statement->ColumnString(13)); |
| std::string request_origin = statement->ColumnString(14); |
| std::string digest = statement->ColumnString(15); |
| |
| OfflinePageItem item(url, id, client_id, path, file_size, creation_time); |
| item.last_access_time = last_access_time; |
| item.access_count = access_count; |
| item.title = title; |
| item.original_url = original_url; |
| item.request_origin = request_origin; |
| item.system_download_id = system_download_id; |
| item.file_missing_time = file_missing_time; |
| item.upgrade_attempt = upgrade_attempt; |
| item.digest = digest; |
| return item; |
| } |
| |
| std::vector<OfflinePageItem> GetOfflinePagesSync(sql::Database* db) { |
| std::vector<OfflinePageItem> result; |
| |
| static const char kSql[] = "SELECT * FROM " OFFLINE_PAGES_TABLE_V1; |
| sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql)); |
| |
| while (statement.Step()) |
| result.push_back(MakeOfflinePageItem(&statement)); |
| |
| if (!statement.Succeeded()) { |
| result.clear(); |
| } |
| return result; |
| } |
| |
| class OfflinePageMetadataStoreTest : public testing::Test { |
| public: |
| OfflinePageMetadataStoreTest() |
| : task_runner_(new base::TestMockTimeTaskRunner), |
| task_runner_handle_(task_runner_) { |
| EXPECT_TRUE(temp_directory_.CreateUniqueTempDir()); |
| } |
| ~OfflinePageMetadataStoreTest() override{}; |
| |
| protected: |
| void TearDown() override { |
| // Wait for all the pieces of the store to delete itself properly. |
| PumpLoop(); |
| } |
| |
| std::unique_ptr<OfflinePageMetadataStore> BuildStore() { |
| auto store = std::make_unique<OfflinePageMetadataStore>( |
| base::ThreadTaskRunnerHandle::Get(), TempPath()); |
| PumpLoop(); |
| return store; |
| } |
| |
| void PumpLoop() { task_runner_->RunUntilIdle(); } |
| void FastForwardBy(base::TimeDelta delta) { |
| task_runner_->FastForwardBy(delta); |
| } |
| |
| base::TestMockTimeTaskRunner* task_runner() const { |
| return task_runner_.get(); |
| } |
| base::FilePath TempPath() const { return temp_directory_.GetPath(); } |
| |
| OfflinePageItem CheckThatStoreHasOneItem(OfflinePageMetadataStore* store) { |
| std::vector<OfflinePageItem> pages = GetOfflinePages(store); |
| EXPECT_EQ(1U, pages.size()); |
| return pages[0]; |
| } |
| |
| void CheckThatOfflinePageCanBeSaved( |
| std::unique_ptr<OfflinePageMetadataStore> store) { |
| size_t store_size = GetOfflinePages(store.get()).size(); |
| OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1, |
| base::FilePath(kFilePath), kFileSize); |
| offline_page.title = base::UTF8ToUTF16("a title"); |
| offline_page.original_url = GURL(kOriginalTestURL); |
| offline_page.system_download_id = kTestSystemDownloadId; |
| offline_page.digest = kTestDigest; |
| |
| EXPECT_EQ(ItemActionStatus::SUCCESS, |
| AddOfflinePage(store.get(), offline_page)); |
| |
| // Close the store first to ensure file lock is removed. |
| store.reset(); |
| store = BuildStore(); |
| std::vector<OfflinePageItem> pages = GetOfflinePages(store.get()); |
| ASSERT_EQ(store_size + 1, pages.size()); |
| if (store_size > 0 && pages[0].offline_id != offline_page.offline_id) { |
| std::swap(pages[0], pages[1]); |
| } |
| EXPECT_EQ(offline_page, pages[0]); |
| } |
| |
| void CheckThatPageThumbnailCanBeSaved(OfflinePageMetadataStore* store) { |
| OfflinePageThumbnail thumbnail; |
| thumbnail.offline_id = kOfflineId; |
| thumbnail.expiration = kThumbnailExpiration; |
| thumbnail.thumbnail = "content"; |
| |
| AddThumbnail(store, thumbnail); |
| std::vector<OfflinePageThumbnail> thumbnails = GetThumbnails(store); |
| EXPECT_EQ(1UL, thumbnails.size()); |
| EXPECT_EQ(thumbnail, thumbnails[0]); |
| } |
| |
| void VerifyMetaVersions() { |
| sql::Database connection; |
| ASSERT_TRUE(connection.Open(temp_directory_.GetPath().Append( |
| FILE_PATH_LITERAL("OfflinePages.db")))); |
| ASSERT_TRUE(connection.is_open()); |
| EXPECT_TRUE(sql::MetaTable::DoesTableExist(&connection)); |
| sql::MetaTable meta_table; |
| EXPECT_TRUE(meta_table.Init(&connection, 1, 1)); |
| |
| EXPECT_EQ(OfflinePageMetadataStore::kCurrentVersion, |
| meta_table.GetVersionNumber()); |
| EXPECT_EQ(OfflinePageMetadataStore::kCompatibleVersion, |
| meta_table.GetCompatibleVersionNumber()); |
| } |
| |
| void LoadAndCheckStore() { |
| auto store = std::make_unique<OfflinePageMetadataStore>( |
| base::ThreadTaskRunnerHandle::Get(), TempPath()); |
| OfflinePageItem item = CheckThatStoreHasOneItem(store.get()); |
| CheckThatPageThumbnailCanBeSaved((OfflinePageMetadataStore*)store.get()); |
| CheckThatOfflinePageCanBeSaved(std::move(store)); |
| VerifyMetaVersions(); |
| } |
| |
| void LoadAndCheckStoreFromMetaVersion1AndUp() { |
| // At meta version 1, more items were added to the database for testing, |
| // which necessitates different checks. |
| auto store = std::make_unique<OfflinePageMetadataStore>( |
| base::ThreadTaskRunnerHandle::Get(), TempPath()); |
| std::vector<OfflinePageItem> pages = GetOfflinePages(store.get()); |
| EXPECT_EQ(5U, pages.size()); |
| |
| // TODO(fgorski): Use persistent namespaces from the client policy |
| // controller once an appropriate method is available. |
| std::set<std::string> upgradeable_namespaces{ |
| kAsyncNamespace, kDownloadNamespace, kBrowserActionsNamespace, |
| kNTPSuggestionsNamespace}; |
| |
| for (const OfflinePageItem& page : pages) { |
| if (upgradeable_namespaces.count(page.client_id.name_space) > 0) |
| EXPECT_EQ(5, page.upgrade_attempt); |
| else |
| EXPECT_EQ(0, page.upgrade_attempt); |
| } |
| CheckThatPageThumbnailCanBeSaved((OfflinePageMetadataStore*)store.get()); |
| CheckThatOfflinePageCanBeSaved(std::move(store)); |
| VerifyMetaVersions(); |
| } |
| |
| template <typename T> |
| T ExecuteSync(OfflinePageMetadataStore* store, |
| base::OnceCallback<T(sql::Database*)> run_callback, |
| T default_value) { |
| bool called = false; |
| T result; |
| auto result_callback = base::BindLambdaForTesting([&](T async_result) { |
| result = std::move(async_result); |
| called = true; |
| }); |
| store->Execute<T>(std::move(run_callback), result_callback, default_value); |
| PumpLoop(); |
| EXPECT_TRUE(called); |
| return result; |
| } |
| |
| void GetOfflinePagesAsync( |
| OfflinePageMetadataStore* store, |
| base::OnceCallback<void(std::vector<OfflinePageItem>)> callback) { |
| auto run_callback = base::BindOnce(&GetOfflinePagesSync); |
| store->Execute<std::vector<OfflinePageItem>>(std::move(run_callback), |
| std::move(callback), {}); |
| } |
| |
| std::vector<OfflinePageItem> GetOfflinePages( |
| OfflinePageMetadataStore* store) { |
| return ExecuteSync<std::vector<OfflinePageItem>>( |
| store, base::BindOnce(&GetOfflinePagesSync), {}); |
| } |
| |
| ItemActionStatus AddOfflinePage(OfflinePageMetadataStore* store, |
| const OfflinePageItem& item) { |
| auto result_callback = base::BindLambdaForTesting([&](sql::Database* db) { |
| // Using 'INSERT OR FAIL' or 'INSERT OR ABORT' in the query below |
| // causes debug builds to DLOG. |
| static const char kSql[] = |
| "INSERT OR IGNORE INTO " OFFLINE_PAGES_TABLE_V1 |
| " (offline_id, online_url, client_namespace, client_id, " |
| "file_path, " |
| "file_size, creation_time, last_access_time, access_count, " |
| "title, original_url, request_origin, system_download_id, " |
| "file_missing_time, upgrade_attempt, digest)" |
| " VALUES " |
| " (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"; |
| |
| sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql)); |
| statement.BindInt64(0, item.offline_id); |
| statement.BindString(1, item.url.spec()); |
| statement.BindString(2, item.client_id.name_space); |
| statement.BindString(3, item.client_id.id); |
| statement.BindString(4, store_utils::ToDatabaseFilePath(item.file_path)); |
| statement.BindInt64(5, item.file_size); |
| statement.BindInt64(6, store_utils::ToDatabaseTime(item.creation_time)); |
| statement.BindInt64(7, |
| store_utils::ToDatabaseTime(item.last_access_time)); |
| statement.BindInt(8, item.access_count); |
| statement.BindString16(9, item.title); |
| statement.BindString(10, item.original_url.spec()); |
| statement.BindString(11, item.request_origin); |
| statement.BindInt64(12, item.system_download_id); |
| statement.BindInt64(13, |
| store_utils::ToDatabaseTime(item.file_missing_time)); |
| statement.BindInt(14, item.upgrade_attempt); |
| statement.BindString(15, item.digest); |
| |
| if (!statement.Run()) |
| return ItemActionStatus::STORE_ERROR; |
| if (db->GetLastChangeCount() == 0) |
| return ItemActionStatus::ALREADY_EXISTS; |
| return ItemActionStatus::SUCCESS; |
| }); |
| return ExecuteSync<ItemActionStatus>(store, result_callback, |
| ItemActionStatus::SUCCESS); |
| } |
| |
| std::vector<OfflinePageThumbnail> GetThumbnails( |
| OfflinePageMetadataStore* store) { |
| std::vector<OfflinePageThumbnail> thumbnails; |
| auto run_callback = base::BindLambdaForTesting([&](sql::Database* db) { |
| static const char kSql[] = "SELECT * FROM page_thumbnails"; |
| sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql)); |
| |
| while (statement.Step()) { |
| OfflinePageThumbnail thumb; |
| thumb.offline_id = statement.ColumnInt64(0); |
| thumb.expiration = |
| store_utils::FromDatabaseTime(statement.ColumnInt64(1)); |
| statement.ColumnBlobAsString(2, &thumb.thumbnail); |
| thumbnails.push_back(std::move(thumb)); |
| } |
| |
| EXPECT_TRUE(statement.Succeeded()); |
| return thumbnails; |
| }); |
| return ExecuteSync<std::vector<OfflinePageThumbnail>>(store, run_callback, |
| {}); |
| } |
| |
| void AddThumbnail(OfflinePageMetadataStore* store, |
| const OfflinePageThumbnail& thumbnail) { |
| std::vector<OfflinePageThumbnail> thumbnails; |
| auto run_callback = base::BindLambdaForTesting([&](sql::Database* db) { |
| static const char kSql[] = |
| "INSERT INTO page_thumbnails" |
| " (offline_id, expiration, thumbnail) VALUES (?, ?, ?)"; |
| sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql)); |
| |
| statement.BindInt64(0, thumbnail.offline_id); |
| statement.BindInt64(1, store_utils::ToDatabaseTime(thumbnail.expiration)); |
| statement.BindString(2, thumbnail.thumbnail); |
| EXPECT_TRUE(statement.Run()); |
| return thumbnails; |
| }); |
| ExecuteSync<std::vector<OfflinePageThumbnail>>(store, run_callback, {}); |
| } |
| |
| protected: |
| base::ScopedTempDir temp_directory_; |
| scoped_refptr<base::TestMockTimeTaskRunner> task_runner_; |
| base::ThreadTaskRunnerHandle task_runner_handle_; |
| }; |
| |
| // 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(0U, GetOfflinePages(store.get()).size()); |
| } |
| |
| TEST_F(OfflinePageMetadataStoreTest, GetOfflinePagesFromInvalidStore) { |
| std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); |
| |
| // Because execute method is self-healing this part of the test expects a |
| // positive results now. |
| store->SetStateForTesting(StoreState::NOT_LOADED, false); |
| EXPECT_EQ(0UL, GetOfflinePages(store.get()).size()); |
| EXPECT_EQ(StoreState::LOADED, store->GetStateForTesting()); |
| |
| store->SetStateForTesting(StoreState::FAILED_LOADING, false); |
| EXPECT_EQ(0UL, GetOfflinePages(store.get()).size()); |
| EXPECT_EQ(StoreState::FAILED_LOADING, store->GetStateForTesting()); |
| |
| store->SetStateForTesting(StoreState::FAILED_RESET, false); |
| EXPECT_EQ(0UL, GetOfflinePages(store.get()).size()); |
| EXPECT_EQ(StoreState::FAILED_RESET, store->GetStateForTesting()); |
| |
| store->SetStateForTesting(StoreState::LOADED, true); |
| EXPECT_EQ(0UL, GetOfflinePages(store.get()).size()); |
| |
| store->SetStateForTesting(StoreState::NOT_LOADED, true); |
| EXPECT_EQ(0UL, GetOfflinePages(store.get()).size()); |
| |
| store->SetStateForTesting(StoreState::FAILED_LOADING, false); |
| EXPECT_EQ(0UL, GetOfflinePages(store.get()).size()); |
| |
| store->SetStateForTesting(StoreState::FAILED_RESET, false); |
| EXPECT_EQ(0UL, GetOfflinePages(store.get()).size()); |
| } |
| |
| // Loads a store which has an outdated schema. |
| // These tests would crash if it's not handling correctly when we're loading |
| // old version stores. |
| TEST_F(OfflinePageMetadataStoreTest, LoadVersion52Store) { |
| BuildTestStoreWithSchemaFromM52(TempPath()); |
| LoadAndCheckStore(); |
| } |
| TEST_F(OfflinePageMetadataStoreTest, LoadVersion53Store) { |
| BuildTestStoreWithSchemaFromM53(TempPath()); |
| LoadAndCheckStore(); |
| } |
| TEST_F(OfflinePageMetadataStoreTest, LoadVersion54Store) { |
| BuildTestStoreWithSchemaFromM54(TempPath()); |
| LoadAndCheckStore(); |
| } |
| TEST_F(OfflinePageMetadataStoreTest, LoadVersion55Store) { |
| BuildTestStoreWithSchemaFromM55(TempPath()); |
| LoadAndCheckStore(); |
| } |
| TEST_F(OfflinePageMetadataStoreTest, LoadVersion56Store) { |
| BuildTestStoreWithSchemaFromM56(TempPath()); |
| LoadAndCheckStore(); |
| } |
| TEST_F(OfflinePageMetadataStoreTest, LoadVersion57Store) { |
| BuildTestStoreWithSchemaFromM57(TempPath()); |
| LoadAndCheckStore(); |
| } |
| TEST_F(OfflinePageMetadataStoreTest, LoadVersion61Store) { |
| BuildTestStoreWithSchemaFromM61(TempPath()); |
| LoadAndCheckStore(); |
| } |
| TEST_F(OfflinePageMetadataStoreTest, LoadVersion62Store) { |
| BuildTestStoreWithSchemaFromM62(TempPath()); |
| LoadAndCheckStore(); |
| } |
| |
| TEST_F(OfflinePageMetadataStoreTest, LoadStoreWithMetaVersion1) { |
| BuildTestStoreWithSchemaVersion1(TempPath()); |
| LoadAndCheckStoreFromMetaVersion1AndUp(); |
| } |
| |
| TEST_F(OfflinePageMetadataStoreTest, LoadStoreWithMetaVersion2) { |
| BuildTestStoreWithSchemaVersion2(TempPath()); |
| LoadAndCheckStoreFromMetaVersion1AndUp(); |
| } |
| |
| // Adds metadata of an offline page into a store and then opens the store |
| // again to make sure that stored metadata survives store restarts. |
| TEST_F(OfflinePageMetadataStoreTest, AddOfflinePage) { |
| CheckThatOfflinePageCanBeSaved(BuildStore()); |
| } |
| |
| TEST_F(OfflinePageMetadataStoreTest, AddSameOfflinePageTwice) { |
| std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); |
| |
| OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1, |
| base::FilePath(kFilePath), kFileSize); |
| offline_page.title = base::UTF8ToUTF16("a title"); |
| |
| EXPECT_EQ(ItemActionStatus::SUCCESS, |
| AddOfflinePage(store.get(), offline_page)); |
| |
| EXPECT_EQ(ItemActionStatus::ALREADY_EXISTS, |
| AddOfflinePage(store.get(), offline_page)); |
| } |
| |
| // Adds metadata of multiple offline pages into a store and removes some. |
| TEST_F(OfflinePageMetadataStoreTest, AddRemoveMultipleOfflinePages) { |
| std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); |
| |
| // Add an offline page. |
| OfflinePageItem offline_page_1(GURL(kTestURL), 12345LL, kTestClientId1, |
| base::FilePath(kFilePath), kFileSize); |
| EXPECT_EQ(ItemActionStatus::SUCCESS, |
| AddOfflinePage(store.get(), offline_page_1)); |
| |
| // Add anther offline page. |
| base::FilePath file_path_2 = |
| base::FilePath(FILE_PATH_LITERAL("//other.page.com.mhtml")); |
| OfflinePageItem offline_page_2(GURL("https://other.page.com"), 5678LL, |
| kTestClientId2, file_path_2, 12345, |
| OfflineTimeNow(), kTestRequestOrigin); |
| offline_page_2.original_url = GURL("https://example.com/bar"); |
| offline_page_2.system_download_id = kTestSystemDownloadId; |
| offline_page_2.digest = kTestDigest; |
| |
| EXPECT_EQ(ItemActionStatus::SUCCESS, |
| AddOfflinePage(store.get(), offline_page_2)); |
| |
| // Get all pages from the store. |
| std::vector<OfflinePageItem> pages = GetOfflinePages(store.get()); |
| EXPECT_EQ(2U, pages.size()); |
| |
| // Close and reload the store. |
| store.reset(); |
| store = BuildStore(); |
| pages = GetOfflinePages(store.get()); |
| ASSERT_EQ(2U, pages.size()); |
| EXPECT_EQ(offline_page_2, pages[0]); |
| } |
| |
| TEST_F(OfflinePageMetadataStoreTest, StoreCloses) { |
| std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); |
| GetOfflinePages(store.get()); |
| |
| EXPECT_TRUE(task_runner()->HasPendingTask()); |
| EXPECT_LT(base::TimeDelta(), task_runner()->NextPendingTaskDelay()); |
| |
| FastForwardBy(OfflinePageMetadataStore::kClosingDelay); |
| PumpLoop(); |
| EXPECT_EQ(StoreState::NOT_LOADED, store->GetStateForTesting()); |
| |
| // Ensure that next call to the store will actually reinitialize it. |
| EXPECT_EQ(0U, GetOfflinePages(store.get()).size()); |
| EXPECT_EQ(StoreState::LOADED, store->GetStateForTesting()); |
| } |
| |
| TEST_F(OfflinePageMetadataStoreTest, MultiplePendingCalls) { |
| auto store = std::make_unique<OfflinePageMetadataStore>( |
| base::ThreadTaskRunnerHandle::Get(), TempPath()); |
| EXPECT_FALSE(task_runner()->HasPendingTask()); |
| EXPECT_EQ(StoreState::NOT_LOADED, store->GetStateForTesting()); |
| |
| // First call flips the state to initializing. |
| // Subsequent calls should be pending until store is initialized. |
| int callback_count = 0; |
| auto get_complete = |
| base::BindLambdaForTesting([&](std::vector<OfflinePageItem> pages) { |
| ++callback_count; |
| EXPECT_TRUE(pages.empty()); |
| }); |
| GetOfflinePagesAsync(store.get(), get_complete); |
| EXPECT_EQ(StoreState::INITIALIZING, store->GetStateForTesting()); |
| |
| GetOfflinePagesAsync(store.get(), get_complete); |
| EXPECT_EQ(0U, GetOfflinePages(store.get()).size()); |
| EXPECT_EQ(StoreState::LOADED, store->GetStateForTesting()); |
| EXPECT_EQ(2, callback_count); |
| } |
| |
| } // namespace |
| } // namespace offline_pages |
