sync: Specialize functions that fetch type root

sync/internal_api/sync_manager_impl_unittest.cc

 // Copyright 2012 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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 156 matching lines @@
   return entry.GetMetahandle();
 }
 
 // Simulates creating a "synced" node as a child of the root datatype node.
 int64 MakeServerNode(UserShare* share, ModelType model_type,
                      const std::string& client_tag,
                      const std::string& hashed_tag,
                      const sync_pb::EntitySpecifics& specifics) {
   syncable::WriteTransaction trans(
       FROM_HERE, syncable::UNITTEST, share->directory.get());
-  syncable::Entry root_entry(&trans, syncable::GET_BY_SERVER_TAG,
-                             ModelTypeToRootTag(model_type));
+  syncable::Entry root_entry(&trans, syncable::GET_TYPE_ROOT, model_type);
   EXPECT_TRUE(root_entry.good());
   syncable::Id root_id = root_entry.GetId();
   syncable::Id node_id = syncable::Id::CreateFromServerId(client_tag);
   syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
                                node_id);
   EXPECT_TRUE(entry.good());
   entry.PutBaseVersion(1);
   entry.PutServerVersion(1);
   entry.PutIsUnappliedUpdate(false);
   entry.PutServerParentId(root_id);
@@ skipping 387 matching lines @@
 TEST_F(SyncApiTest, EmptyTags) {
   WriteTransaction trans(FROM_HERE, user_share());
   ReadNode root_node(&trans);
   root_node.InitByRootLookup();
   WriteNode node(&trans);
   std::string empty_tag;
   WriteNode::InitUniqueByCreationResult result =
       node.InitUniqueByCreation(TYPED_URLS, root_node, empty_tag);
   EXPECT_NE(WriteNode::INIT_SUCCESS, result);
   EXPECT_EQ(BaseNode::INIT_FAILED_PRECONDITION,
-            node.InitByTagLookup(empty_tag));
+            node.InitByClientTagLookup(TYPED_URLS, empty_tag));
 }
 
 // Test counting nodes when the type's root node has no children.
 TEST_F(SyncApiTest, GetTotalNodeCountEmpty) {
   int64 type_root = MakeServerNodeForType(user_share(), BOOKMARKS);
   {
     ReadTransaction trans(FROM_HERE, user_share());
     ReadNode type_root_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               type_root_node.InitByIdLookup(type_root));
@@ skipping 644 matching lines @@
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(
       "new_passphrase",
       false);
   EXPECT_EQ(IMPLICIT_PASSPHRASE,
             sync_manager_.GetEncryptionHandler()->GetPassphraseType());
   EXPECT_FALSE(EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encryption_keybag()));
   }
 }
 
 // Test that when there are no pending keys and we have on the old GAIA
 // password, we update and re-encrypt everything with the new GAIA password.
 // (case 1 in SyncManager::SyncInternal::SetEncryptionPassphrase)
@@ skipping 99 matching lines @@
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     other_cryptographer.Bootstrap(bootstrap_token);
 
     // Now update the nigori to reflect the new keys, and update the
     // cryptographer to have pending keys.
     KeyParams params = {"localhost", "dummy", "passphrase2"};
     other_cryptographer.AddKey(params);
     WriteNode node(&trans);
-    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     cryptographer->SetPendingKeys(nigori.encryption_keybag());
     EXPECT_TRUE(cryptographer->has_pending_keys());
     node.SetNigoriSpecifics(nigori);
   }
   EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(encryption_observer_, OnPassphraseAccepted());
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
@@ skipping 27 matching lines @@
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     other_cryptographer.Bootstrap(bootstrap_token);
 
     // Now update the nigori to reflect the new keys, and update the
     // cryptographer to have pending keys.
     KeyParams params = {"localhost", "dummy", "old_gaia"};
     other_cryptographer.AddKey(params);
     WriteNode node(&trans);
-    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     node.SetNigoriSpecifics(nigori);
     cryptographer->SetPendingKeys(nigori.encryption_keybag());
 
     // other_cryptographer now contains all encryption keys, and is encrypting
     // with the newest gaia.
     KeyParams new_params = {"localhost", "dummy", "new_gaia"};
     other_cryptographer.AddKey(new_params);
   }
@@ skipping 62 matching lines @@
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     other_cryptographer.Bootstrap(bootstrap_token);
 
     // Now update the nigori to reflect the new keys, and update the
     // cryptographer to have pending keys.
     KeyParams params = {"localhost", "dummy", "explicit"};
     other_cryptographer.AddKey(params);
     WriteNode node(&trans);
-    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     cryptographer->SetPendingKeys(nigori.encryption_keybag());
     EXPECT_TRUE(cryptographer->has_pending_keys());
     nigori.set_keybag_is_frozen(true);
     node.SetNigoriSpecifics(nigori);
   }
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_,
               OnPassphraseTypeChanged(CUSTOM_PASSPHRASE, _));
@@ skipping 28 matching lines @@
   EXPECT_FALSE(SetUpEncryption(DONT_WRITE_NIGORI, UNINITIALIZED));
   Cryptographer other_cryptographer(&encryptor_);
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     // Now update the nigori to reflect the new keys, and update the
     // cryptographer to have pending keys.
     KeyParams params = {"localhost", "dummy", "passphrase"};
     other_cryptographer.AddKey(params);
     WriteNode node(&trans);
-    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     node.SetNigoriSpecifics(nigori);
     cryptographer->SetPendingKeys(nigori.encryption_keybag());
     EXPECT_FALSE(cryptographer->is_ready());
   }
   EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(encryption_observer_, OnPassphraseAccepted());
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
@@ skipping 174 matching lines @@
 
 // Create a bookmark and set the title/url, then verify the data was properly
 // set. This replicates the unique way bookmarks have of creating sync nodes.
 // See BookmarkChangeProcessor::PlaceSyncNode(..).
 TEST_F(SyncManagerTest, CreateLocalBookmark) {
   std::string title = "title";
   std::string url = "url";
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode bookmark_root(&trans);
-    ASSERT_EQ(BaseNode::INIT_OK,
-              bookmark_root.InitByTagLookup(ModelTypeToRootTag(BOOKMARKS)));
+    ASSERT_EQ(BaseNode::INIT_OK, bookmark_root.InitTypeRoot(BOOKMARKS));
     WriteNode node(&trans);
     ASSERT_TRUE(node.InitBookmarkByCreation(bookmark_root, NULL));
     node.SetIsFolder(false);
     node.SetTitle(title);
 
     sync_pb::BookmarkSpecifics bookmark_specifics(node.GetBookmarkSpecifics());
     bookmark_specifics.set_url(url);
     node.SetBookmarkSpecifics(bookmark_specifics);
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode bookmark_root(&trans);
-    ASSERT_EQ(BaseNode::INIT_OK,
-              bookmark_root.InitByTagLookup(ModelTypeToRootTag(BOOKMARKS)));
+    ASSERT_EQ(BaseNode::INIT_OK, bookmark_root.InitTypeRoot(BOOKMARKS));
     int64 child_id = bookmark_root.GetFirstChildId();
 
     ReadNode node(&trans);
     ASSERT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
     EXPECT_FALSE(node.GetIsFolder());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
   }
 }
 
@@ skipping 804 matching lines @@
 
   UserShare* share = sync_manager_.GetUserShare();
 
   // The test harness automatically initializes all types in the routing info.
   // Check that autofill is not among them.
   ASSERT_FALSE(enabled_types.Has(AUTOFILL));
 
   // Further ensure that the test harness did not create its root node.
   {
     syncable::ReadTransaction trans(FROM_HERE, share->directory.get());
-    syncable::Entry autofill_root_node(&trans, syncable::GET_BY_SERVER_TAG,
-                                       ModelTypeToRootTag(AUTOFILL));
+    syncable::Entry autofill_root_node(&trans,
+                                       syncable::GET_TYPE_ROOT,
+                                       AUTOFILL);
     ASSERT_FALSE(autofill_root_node.good());
   }
 
   // One more redundant check.
   ASSERT_FALSE(sync_manager_.InitialSyncEndedTypes().Has(AUTOFILL));
 
   // Give autofill a progress marker.
   sync_pb::DataTypeProgressMarker autofill_marker;
   autofill_marker.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(AUTOFILL));
@@ skipping 537 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer