[Sync] Prepend global metadata key with model type prefix

components/sync/model_impl/model_type_store_impl_unittest.cc

Index: components/sync/model_impl/model_type_store_impl_unittest.cc
diff --git a/components/sync/model_impl/model_type_store_impl_unittest.cc b/components/sync/model_impl/model_type_store_impl_unittest.cc
index 43c0b8cda5ca7e2ac25d9b4e83f1b5bad4a59683..6d3202ad038aad12b122b93764e8bdbca2b66da2 100644
--- a/components/sync/model_impl/model_type_store_impl_unittest.cc
+++ b/components/sync/model_impl/model_type_store_impl_unittest.cc
@@ -25,33 +25,85 @@ class ModelTypeStoreImplTest : public testing::Test {
 
   ModelTypeStore* store() { return store_.get(); }
 
-  void OnInitDone(ModelTypeStore::Result result,
-                  std::unique_ptr<ModelTypeStore> store) {
+  static void OnStoreCreated(std::unique_ptr<ModelTypeStore>* store_ref,
+                             ModelTypeStore::Result result,
+                             std::unique_ptr<ModelTypeStore> store) {
     ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
-    store_ = std::move(store);
+    *store_ref = std::move(store);
   }
 
-  void PumpLoop() {
+  static void PumpLoop() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
-  void CreateStore() {
-    ModelTypeStore::CreateInMemoryStoreForTest(base::Bind(
-        &ModelTypeStoreImplTest::OnInitDone, base::Unretained(this)));
+  static void CreateStoreCaptureReference(
+      const ModelType type,
+      std::unique_ptr<ModelTypeStore>* store_ref) {
+    ModelTypeStore::CreateInMemoryStoreForTest(
+        type, base::Bind(&ModelTypeStoreImplTest::OnStoreCreated, store_ref));
     PumpLoop();
   }
 
-  void WriteTestData() {
+  void CreateStore() { CreateStoreCaptureReference(UNSPECIFIED, &store_); }
+
+  static void WriteData(ModelTypeStore* store,
+                        const std::string& key,
+                        const std::string& data) {
+    std::unique_ptr<ModelTypeStore::WriteBatch> write_batch =
+        store->CreateWriteBatch();
+    store->WriteData(write_batch.get(), key, data);
+    ModelTypeStore::Result result;
+    store->CommitWriteBatch(std::move(write_batch),
+                            base::Bind(&CaptureResult, &result));
+    PumpLoop();
+    ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
+  }
+
+  static void WriteMetadata(ModelTypeStore* store,
+                            const std::string& key,
+                            const std::string& metadata) {
     std::unique_ptr<ModelTypeStore::WriteBatch> write_batch =
-        store()->CreateWriteBatch();
-    store()->WriteData(write_batch.get(), "id1", "data1");
-    store()->WriteMetadata(write_batch.get(), "id1", "metadata1");
-    store()->WriteData(write_batch.get(), "id2", "data2");
-    store()->WriteGlobalMetadata(write_batch.get(), "global_metadata");
+        store->CreateWriteBatch();
+    store->WriteMetadata(write_batch.get(), key, metadata);
     ModelTypeStore::Result result;
-    store()->CommitWriteBatch(std::move(write_batch),
-                              base::Bind(&CaptureResult, &result));
+    store->CommitWriteBatch(std::move(write_batch),
+                            base::Bind(&CaptureResult, &result));
+    PumpLoop();
+    ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
+  }
+
+  static void WriteGlobalMetadata(ModelTypeStore* store,
+                                  const std::string& metadata) {
+    std::unique_ptr<ModelTypeStore::WriteBatch> write_batch =
+        store->CreateWriteBatch();
+    store->WriteGlobalMetadata(write_batch.get(), metadata);
+    ModelTypeStore::Result result;
+    store->CommitWriteBatch(std::move(write_batch),
+                            base::Bind(&CaptureResult, &result));
+    PumpLoop();
+    ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
+  }
+
+  void WriteTestData() {
+    WriteData(store(), "id1", "data1");
+    WriteMetadata(store(), "id1", "metadata1");
+    WriteData(store(), "id2", "data2");
+    WriteGlobalMetadata(store(), "global_metadata");
+  }
+
+  static void ReadStoreContents(
+      ModelTypeStore* store,
+      std::unique_ptr<ModelTypeStore::RecordList>* data_records,
+      std::unique_ptr<ModelTypeStore::RecordList>* metadata_records,
+      std::string* global_metadata) {
+    ModelTypeStore::Result result;
+    store->ReadAllData(
+        base::Bind(&CaptureResultWithRecords, &result, data_records));
+    PumpLoop();
+    ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
+    store->ReadAllMetadata(base::Bind(&CaptureResutRecordsAndString, &result,
+                                      metadata_records, global_metadata));
     PumpLoop();
     ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
   }
@@ -108,29 +160,27 @@ MATCHER_P2(RecordMatches, id, value, "") {
 }
 
 // Test that CreateInMemoryStoreForTest triggers store initialization that
-// results with callback being called with valid store pointer. Test that
-// resulting store is empty functional one.
+// results with callback being called with valid store pointer.
 TEST_F(ModelTypeStoreImplTest, CreateInMemoryStore) {
+  std::unique_ptr<ModelTypeStore> store;
   ModelTypeStore::CreateInMemoryStoreForTest(
-      base::Bind(&ModelTypeStoreImplTest::OnInitDone, base::Unretained(this)));
-  ASSERT_EQ(nullptr, store());
+      UNSPECIFIED, base::Bind(&ModelTypeStoreImplTest::OnStoreCreated, &store));
+  ASSERT_EQ(nullptr, store);
   PumpLoop();
-  ASSERT_NE(nullptr, store());
+  ASSERT_NE(nullptr, store);
+}
 
-  ModelTypeStore::Result result;
-  std::unique_ptr<ModelTypeStore::RecordList> records;
-  store()->ReadAllData(
-      base::Bind(&CaptureResultWithRecords, &result, &records));
-  PumpLoop();
-  ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
-  ASSERT_TRUE(records->empty());
+// Test read functions on empty store.
+TEST_F(ModelTypeStoreImplTest, ReadEmptyStore) {
+  CreateStore();
 
+  std::unique_ptr<ModelTypeStore::RecordList> data_records;
+  std::unique_ptr<ModelTypeStore::RecordList> metadata_records;
   std::string global_metadata;
-  store()->ReadAllMetadata(base::Bind(&CaptureResutRecordsAndString, &result,
-                                      &records, &global_metadata));
-  PumpLoop();
-  ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
-  ASSERT_TRUE(records->empty());
+  ReadStoreContents(store(), &data_records, &metadata_records,
+                    &global_metadata);
+  ASSERT_TRUE(data_records->empty());
+  ASSERT_TRUE(metadata_records->empty());
   ASSERT_TRUE(global_metadata.empty());
 }
 
@@ -139,23 +189,16 @@ TEST_F(ModelTypeStoreImplTest, WriteThenRead) {
   CreateStore();
   WriteTestData();
 
-  ModelTypeStore::Result result;
-  std::unique_ptr<ModelTypeStore::RecordList> records;
-  store()->ReadAllData(
-      base::Bind(&CaptureResultWithRecords, &result, &records));
-  PumpLoop();
-  ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
-  ASSERT_THAT(*records,
+  std::unique_ptr<ModelTypeStore::RecordList> data_records;
+  std::unique_ptr<ModelTypeStore::RecordList> metadata_records;
+  std::string global_metadata;
+  ReadStoreContents(store(), &data_records, &metadata_records,
+                    &global_metadata);
+  ASSERT_THAT(*data_records,
               testing::UnorderedElementsAre(RecordMatches("id1", "data1"),
                                             RecordMatches("id2", "data2")));
-
-  std::string global_metadata;
-  store()->ReadAllMetadata(base::Bind(&CaptureResutRecordsAndString, &result,
-                                      &records, &global_metadata));
-  PumpLoop();
-  ASSERT_EQ(ModelTypeStore::Result::SUCCESS, result);
-  ASSERT_THAT(*records,
-              testing::UnorderedElementsAre(RecordMatches("id1", "metadata1")));
+  ASSERT_THAT(*metadata_records,
+              testing::ElementsAre(RecordMatches("id1", "metadata1")));
   ASSERT_EQ("global_metadata", global_metadata);
 }
 
@@ -210,4 +253,43 @@ TEST_F(ModelTypeStoreImplTest, ReadMissingDataRecords) {
   ASSERT_THAT(*missing_id_list, testing::UnorderedElementsAre("id3"));
 }
 
+// Test that stores for different types that share the same backend don't
+// interfere with each other's records.
+TEST_F(ModelTypeStoreImplTest, TwoStoresWithSharedBackend) {
+  std::unique_ptr<ModelTypeStore> store_1;
+  std::unique_ptr<ModelTypeStore> store_2;
+  CreateStoreCaptureReference(AUTOFILL, &store_1);
+  CreateStoreCaptureReference(BOOKMARKS, &store_2);
+
+  WriteData(store_1.get(), "key", "data1");
+  WriteMetadata(store_1.get(), "key", "metadata1");
+  WriteGlobalMetadata(store_1.get(), "global1");
+
+  WriteData(store_2.get(), "key", "data2");
+  WriteMetadata(store_2.get(), "key", "metadata2");
+  WriteGlobalMetadata(store_2.get(), "global2");
+
+  std::unique_ptr<ModelTypeStore::RecordList> data_records;
+  std::unique_ptr<ModelTypeStore::RecordList> metadata_records;
+  std::string global_metadata;
+
+  ReadStoreContents(store_1.get(), &data_records, &metadata_records,
+                    &global_metadata);
+
+  EXPECT_THAT(*data_records,
+              testing::ElementsAre(RecordMatches("key", "data1")));
+  EXPECT_THAT(*metadata_records,
+              testing::ElementsAre(RecordMatches("key", "metadata1")));
+  EXPECT_EQ("global1", global_metadata);
+
+  ReadStoreContents(store_2.get(), &data_records, &metadata_records,
+                    &global_metadata);
+
+  EXPECT_THAT(*data_records,
+              testing::ElementsAre(RecordMatches("key", "data2")));
+  EXPECT_THAT(*metadata_records,
+              testing::ElementsAre(RecordMatches("key", "metadata2")));
+  EXPECT_EQ("global2", global_metadata);
+}
+
 }  // namespace syncer