sync: remove use of protobuf extensions in protocol to reduce static init overhead.

chrome/browser/sync/internal_api/syncapi_unittest.cc

 // Copyright (c) 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 152 matching lines @@
   node.SetIsFolder(true);
   return node.GetId();
 }
 
 // Creates the "synced" root node for a particular datatype. We use the syncable
 // methods here so that the syncer treats these nodes as if they were already
 // received from the server.
 int64 MakeServerNodeForType(UserShare* share,
                             ModelType model_type) {
   sync_pb::EntitySpecifics specifics;
-  syncable::AddDefaultExtensionValue(model_type, &specifics);
+  syncable::AddDefaultFieldValue(model_type, &specifics);
   syncable::WriteTransaction trans(
       FROM_HERE, syncable::UNITTEST, share->directory.get());
   // Attempt to lookup by nigori tag.
   std::string type_tag = syncable::ModelTypeToRootTag(model_type);
   syncable::Id node_id = syncable::Id::CreateFromServerId(type_tag);
   syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
                                node_id);
   EXPECT_TRUE(entry.good());
   entry.Put(syncable::BASE_VERSION, 1);
   entry.Put(syncable::SERVER_VERSION, 1);
@@ skipping 317 matching lines @@
 }
 
 TEST_F(SyncApiTest, BaseNodeSetSpecifics) {
   int64 child_id = MakeNode(test_user_share_.user_share(),
                             syncable::BOOKMARKS, "testtag");
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   WriteNode node(&trans);
   EXPECT_TRUE(node.InitByIdLookup(child_id));
 
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::bookmark)->
-      set_url("http://www.google.com");
+  entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
 
   EXPECT_NE(entity_specifics.SerializeAsString(),
             node.GetEntitySpecifics().SerializeAsString());
   node.SetEntitySpecifics(entity_specifics);
   EXPECT_EQ(entity_specifics.SerializeAsString(),
             node.GetEntitySpecifics().SerializeAsString());
 }
 
 TEST_F(SyncApiTest, BaseNodeSetSpecificsPreservesUnknownFields) {
   int64 child_id = MakeNode(test_user_share_.user_share(),
                             syncable::BOOKMARKS, "testtag");
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   WriteNode node(&trans);
   EXPECT_TRUE(node.InitByIdLookup(child_id));
   EXPECT_TRUE(node.GetEntitySpecifics().unknown_fields().empty());
 
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::bookmark)->
-      set_url("http://www.google.com");
+  entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
   entity_specifics.mutable_unknown_fields()->AddFixed32(5, 100);
   node.SetEntitySpecifics(entity_specifics);
   EXPECT_FALSE(node.GetEntitySpecifics().unknown_fields().empty());
 
   entity_specifics.mutable_unknown_fields()->Clear();
   node.SetEntitySpecifics(entity_specifics);
   EXPECT_FALSE(node.GetEntitySpecifics().unknown_fields().empty());
 }
 
 namespace {
@@ skipping 1263 matching lines @@
       "testtag");
   int64 node_id2 = MakeNode(sync_manager_.GetUserShare(),
       syncable::BOOKMARKS,
       "testtag2");
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_TRUE(node.InitByIdLookup(node_id1));
 
     sync_pb::EntitySpecifics entity_specifics;
-    entity_specifics.MutableExtension(sync_pb::bookmark)->set_url(url);
+    entity_specifics.mutable_bookmark()->set_url(url);
     node.SetEntitySpecifics(entity_specifics);
 
     // Set the old style title.
     syncable::MutableEntry* node_entry = node.entry_;
     node_entry->Put(syncable::NON_UNIQUE_NAME, title);
 
     WriteNode node2(&trans);
     EXPECT_TRUE(node2.InitByIdLookup(node_id2));
 
     sync_pb::EntitySpecifics entity_specifics2;
-    entity_specifics2.MutableExtension(sync_pb::bookmark)->set_url(url2);
+    entity_specifics2.mutable_bookmark()->set_url(url2);
     node2.SetEntitySpecifics(entity_specifics2);
 
     // Set the old style title.
     syncable::MutableEntry* node_entry2 = node2.entry_;
     node_entry2->Put(syncable::NON_UNIQUE_NAME, title2);
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
@@ skipping 85 matching lines @@
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(url, node.GetURL());
   }
 }
 
 // Verifies WriteNode::UpdateEntryWithEncryption does not make unnecessary
 // changes.
 TEST_F(SyncManagerTest, UpdateEntryWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::bookmark)->set_url("url");
-  entity_specifics.MutableExtension(sync_pb::bookmark)->set_title("title");
+  entity_specifics.mutable_bookmark()->set_url("url");
+  entity_specifics.mutable_bookmark()->set_title("title");
   MakeServerNode(sync_manager_.GetUserShare(), syncable::BOOKMARKS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
   // Manually change to the same data. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
@@ skipping 87 matching lines @@
     EXPECT_FALSE(node_entry->Get(IS_UNSYNCED));
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to different data. Should set is_unsynced.
   {
-    entity_specifics.MutableExtension(sync_pb::bookmark)->set_url("url2");
-    entity_specifics.MutableExtension(sync_pb::bookmark)->set_title("title2");
+    entity_specifics.mutable_bookmark()->set_url("url2");
+    entity_specifics.mutable_bookmark()->set_title("title2");
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_TRUE(node_entry->Get(IS_UNSYNCED));
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
                     specifics.encrypted()));
   }
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via SetEntitySpecifics.
 TEST_F(SyncManagerTest, UpdatePasswordSetEntitySpecificsNoChange) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
         data,
-        entity_specifics.MutableExtension(sync_pb::password)->
+        entity_specifics.mutable_password()->
             mutable_encrypted());
   }
   MakeServerNode(sync_manager_.GetUserShare(), syncable::PASSWORDS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Manually change to the same data via SetEntitySpecifics. Should not set
@@ skipping 13 matching lines @@
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
         data,
-        entity_specifics.MutableExtension(sync_pb::password)->
+        entity_specifics.mutable_password()->
             mutable_encrypted());
   }
   MakeServerNode(sync_manager_.GetUserShare(), syncable::PASSWORDS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Manually change to the same data via SetPasswordSpecifics. Should not set
   // is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_TRUE(node.InitByClientTagLookup(syncable::PASSWORDS, client_tag));
     node.SetPasswordSpecifics(node.GetPasswordSpecifics());
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Manually change to different data. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_TRUE(node.InitByClientTagLookup(syncable::PASSWORDS, client_tag));
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret2");
     cryptographer->Encrypt(
         data,
-        entity_specifics.MutableExtension(sync_pb::password)->
-            mutable_encrypted());
+        entity_specifics.mutable_password()->mutable_encrypted());
     node.SetPasswordSpecifics(data);
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_TRUE(node_entry->Get(IS_UNSYNCED));
   }
 }
 
 // Passwords have their own handling for encryption. Verify setting a new
 // passphrase updates the data.
 TEST_F(SyncManagerTest, UpdatePasswordNewPassphrase) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
         data,
-        entity_specifics.MutableExtension(sync_pb::password)->
-            mutable_encrypted());
+        entity_specifics.mutable_password()->mutable_encrypted());
   }
   MakeServerNode(sync_manager_.GetUserShare(), syncable::PASSWORDS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Set a new passphrase. Should set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
@@ skipping 10 matching lines @@
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
         data,
-        entity_specifics.MutableExtension(sync_pb::password)->
-            mutable_encrypted());
+        entity_specifics.mutable_password()->mutable_encrypted());
   }
   MakeServerNode(sync_manager_.GetUserShare(), syncable::PASSWORDS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.RefreshNigori(base::Bind(&SyncManagerTest::EmptyClosure,
                                          base::Unretained(this)));
   scoped_refptr<base::ThreadTestHelper> helper(
       new base::ThreadTestHelper(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
   ASSERT_TRUE(helper->Run());
   PumpLoop();
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::bookmark)->set_url("url");
-  entity_specifics.MutableExtension(sync_pb::bookmark)->set_title("title");
+  entity_specifics.mutable_bookmark()->set_url("url");
+  entity_specifics.mutable_bookmark()->set_title("title");
   MakeServerNode(sync_manager_.GetUserShare(), syncable::BOOKMARKS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
@@ skipping 12 matching lines @@
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // bookmarks when we write the same data, but does set it when we write new
 // data.
 TEST_F(SyncManagerTest, SetBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::bookmark)->set_url("url");
-  entity_specifics.MutableExtension(sync_pb::bookmark)->set_title("title");
+  entity_specifics.mutable_bookmark()->set_url("url");
+  entity_specifics.mutable_bookmark()->set_title("title");
   MakeServerNode(sync_manager_.GetUserShare(), syncable::BOOKMARKS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
@@ skipping 36 matching lines @@
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for non-bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetNonBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::preference)->set_name("name");
-  entity_specifics.MutableExtension(sync_pb::preference)->set_value("value");
+  entity_specifics.mutable_preference()->set_name("name");
+  entity_specifics.mutable_preference()->set_value("value");
   MakeServerNode(sync_manager_.GetUserShare(),
                  syncable::PREFERENCES,
                  client_tag,
                  BaseNode::GenerateSyncableHash(syncable::PREFERENCES,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
@@ skipping 14 matching lines @@
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // non-bookmarks when we write the same data or when we write new data
 // data (should remained kEncryptedString).
 TEST_F(SyncManagerTest, SetNonBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::preference)->set_name("name");
-  entity_specifics.MutableExtension(sync_pb::preference)->set_value("value");
+  entity_specifics.mutable_preference()->set_name("name");
+  entity_specifics.mutable_preference()->set_value("value");
   MakeServerNode(sync_manager_.GetUserShare(),
                  syncable::PREFERENCES,
                  client_tag,
                  BaseNode::GenerateSyncableHash(syncable::PREFERENCES,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
@@ skipping 47 matching lines @@
   std::string client_tag = "tag";
   std::string url = "url";
   std::string url2 = "new_url";
   std::string title = "title";
   sync_pb::EntitySpecifics entity_specifics;
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     browser_sync::Cryptographer* crypto = trans.GetCryptographer();
     sync_pb::EntitySpecifics bm_specifics;
-    bm_specifics.MutableExtension(sync_pb::bookmark)->set_title("title");
-    bm_specifics.MutableExtension(sync_pb::bookmark)->set_url("url");
+    bm_specifics.mutable_bookmark()->set_title("title");
+    bm_specifics.mutable_bookmark()->set_url("url");
     sync_pb::EncryptedData encrypted;
     crypto->Encrypt(bm_specifics, &encrypted);
     entity_specifics.mutable_encrypted()->CopyFrom(encrypted);
-    syncable::AddDefaultExtensionValue(syncable::BOOKMARKS, &entity_specifics);
+    syncable::AddDefaultFieldValue(syncable::BOOKMARKS, &entity_specifics);
   }
   MakeServerNode(sync_manager_.GetUserShare(), syncable::BOOKMARKS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
 
   {
     // Verify the data.
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
@@ skipping 18 matching lines @@
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(GURL(url2), node.GetURL());
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
   }
 }
 
 }  // namespace browser_sync