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

chrome/browser/sync/engine/syncer_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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
@@ skipping 216 matching lines @@
   virtual void TearDown() {
     mock_server_.reset();
     delete syncer_;
     syncer_ = NULL;
     dir_maker_.TearDown();
   }
   void WriteTestDataToEntry(WriteTransaction* trans, MutableEntry* entry) {
     EXPECT_FALSE(entry->Get(IS_DIR));
     EXPECT_FALSE(entry->Get(IS_DEL));
     sync_pb::EntitySpecifics specifics;
-    specifics.MutableExtension(sync_pb::bookmark)->set_url("http://demo/");
-    specifics.MutableExtension(sync_pb::bookmark)->set_favicon("PNG");
+    specifics.mutable_bookmark()->set_url("http://demo/");
+    specifics.mutable_bookmark()->set_favicon("PNG");
     entry->Put(syncable::SPECIFICS, specifics);
     entry->Put(syncable::IS_UNSYNCED, true);
   }
   void VerifyTestDataInEntry(BaseTransaction* trans, Entry* entry) {
     EXPECT_FALSE(entry->Get(IS_DIR));
     EXPECT_FALSE(entry->Get(IS_DEL));
     VerifyTestBookmarkDataInEntry(entry);
   }
   void VerifyTestBookmarkDataInEntry(Entry* entry) {
     const sync_pb::EntitySpecifics& specifics = entry->Get(syncable::SPECIFICS);
-    EXPECT_TRUE(specifics.HasExtension(sync_pb::bookmark));
-    EXPECT_EQ("PNG", specifics.GetExtension(sync_pb::bookmark).favicon());
-    EXPECT_EQ("http://demo/", specifics.GetExtension(sync_pb::bookmark).url());
+    EXPECT_TRUE(specifics.has_bookmark());
+    EXPECT_EQ("PNG", specifics.bookmark().favicon());
+    EXPECT_EQ("http://demo/", specifics.bookmark().url());
   }
 
   void SyncRepeatedlyToTriggerConflictResolution(SyncSession* session) {
     // We should trigger after less than 6 syncs, but extra does no harm.
     for (int i = 0 ; i < 6 ; ++i)
       syncer_->SyncShare(session, SYNCER_BEGIN, SYNCER_END);
   }
   void SyncRepeatedlyToTriggerStuckSignal(SyncSession* session) {
     // We should trigger after less than 10 syncs, but we want to avoid brittle
     // tests.
     for (int i = 0 ; i < 12 ; ++i)
       syncer_->SyncShare(session, SYNCER_BEGIN, SYNCER_END);
   }
   sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
     sync_pb::EntitySpecifics result;
-    AddDefaultExtensionValue(syncable::BOOKMARKS, &result);
+    AddDefaultFieldValue(syncable::BOOKMARKS, &result);
     return result;
   }
 
   sync_pb::EntitySpecifics DefaultPreferencesSpecifics() {
     sync_pb::EntitySpecifics result;
-    AddDefaultExtensionValue(syncable::PREFERENCES, &result);
+    AddDefaultFieldValue(syncable::PREFERENCES, &result);
     return result;
   }
   // Enumeration of alterations to entries for commit ordering tests.
   enum EntryFeature {
     LIST_END = 0,  // Denotes the end of the list of features from below.
     SYNCED,  // Items are unsynced by default
     DELETED,
     OLD_MTIME,
     MOVED_FROM_ROOT,
   };
@@ skipping 290 matching lines @@
   expected_order.push_back(ids_.MakeLocal("b"));
   expected_order.push_back(ids_.MakeLocal("c"));
   expected_order.push_back(ids_.MakeLocal("d"));
   expected_order.push_back(ids_.MakeLocal("e"));
   DoTruncationTest(unsynced_handle_view, expected_order);
 }
 
 TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
   const syncable::ModelTypeSet throttled_types(syncable::BOOKMARKS);
   sync_pb::EntitySpecifics bookmark_data;
-  AddDefaultExtensionValue(syncable::BOOKMARKS, &bookmark_data);
+  AddDefaultFieldValue(syncable::BOOKMARKS, &bookmark_data);
 
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   SyncShareAsDelegate();
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(SPECIFICS, bookmark_data);
@@ skipping 44 matching lines @@
     EXPECT_TRUE(parent_id == -1 || \
                 entryA.Get(PARENT_ID) == id_fac.FromNumber(parent_id)); \
     EXPECT_EQ(version, entryA.Get(BASE_VERSION)); \
     EXPECT_EQ(server_version, entryA.Get(SERVER_VERSION)); \
   } while (0)
 
 TEST_F(SyncerTest, GetCommitIdsFiltersUnreadyEntries) {
   KeyParams key_params = {"localhost", "dummy", "foobar"};
   KeyParams other_params = {"localhost", "dummy", "foobar2"};
   sync_pb::EntitySpecifics bookmark, encrypted_bookmark;
-  bookmark.MutableExtension(sync_pb::bookmark)->set_url("url");
-  bookmark.MutableExtension(sync_pb::bookmark)->set_title("title");
-  AddDefaultExtensionValue(syncable::BOOKMARKS, &encrypted_bookmark);
+  bookmark.mutable_bookmark()->set_url("url");
+  bookmark.mutable_bookmark()->set_title("title");
+  AddDefaultFieldValue(syncable::BOOKMARKS, &encrypted_bookmark);
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   mock_server_->AddUpdateDirectory(3, 0, "C", 10, 10);
   mock_server_->AddUpdateDirectory(4, 0, "D", 10, 10);
   SyncShareAsDelegate();
   // Server side change will put A in conflict.
   mock_server_->AddUpdateDirectory(1, 0, "A", 20, 20);
   {
     // Mark bookmarks as encrypted and set the cryptographer to have pending
     // keys.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     browser_sync::Cryptographer other_cryptographer(&encryptor_);
     other_cryptographer.AddKey(other_params);
     sync_pb::EntitySpecifics specifics;
-    sync_pb::NigoriSpecifics* nigori =
-        specifics.MutableExtension(sync_pb::nigori);
+    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     other_cryptographer.GetKeys(nigori->mutable_encrypted());
     nigori->set_encrypt_bookmarks(true);
     // Set up with an old passphrase, but have pending keys
     cryptographer(&wtrans)->AddKey(key_params);
     cryptographer(&wtrans)->Encrypt(bookmark,
                                     encrypted_bookmark.mutable_encrypted());
     cryptographer(&wtrans)->Update(*nigori);
 
     // In conflict but properly encrypted.
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
@@ skipping 77 matching lines @@
     VERIFY_ENTRY(3, false, false, false, 0, 11, 11, ids_, &rtrans);
     VERIFY_ENTRY(4, false, false, false, 0, 11, 11, ids_, &rtrans);
   }
 }
 
 TEST_F(SyncerTest, EncryptionAwareConflicts) {
   KeyParams key_params = {"localhost", "dummy", "foobar"};
   browser_sync::Cryptographer other_cryptographer(&encryptor_);
   other_cryptographer.AddKey(key_params);
   sync_pb::EntitySpecifics bookmark, encrypted_bookmark, modified_bookmark;
-  bookmark.MutableExtension(sync_pb::bookmark)->set_title("title");
+  bookmark.mutable_bookmark()->set_title("title");
   other_cryptographer.Encrypt(bookmark,
                               encrypted_bookmark.mutable_encrypted());
-  AddDefaultExtensionValue(syncable::BOOKMARKS, &encrypted_bookmark);
-  modified_bookmark.MutableExtension(sync_pb::bookmark)->set_title("title2");
+  AddDefaultFieldValue(syncable::BOOKMARKS, &encrypted_bookmark);
+  modified_bookmark.mutable_bookmark()->set_title("title2");
   other_cryptographer.Encrypt(modified_bookmark,
                               modified_bookmark.mutable_encrypted());
   sync_pb::EntitySpecifics pref, encrypted_pref, modified_pref;
-  pref.MutableExtension(sync_pb::preference)->set_name("name");
-  AddDefaultExtensionValue(syncable::PREFERENCES, &encrypted_pref);
+  pref.mutable_preference()->set_name("name");
+  AddDefaultFieldValue(syncable::PREFERENCES, &encrypted_pref);
   other_cryptographer.Encrypt(pref,
                               encrypted_pref.mutable_encrypted());
-  modified_pref.MutableExtension(sync_pb::preference)->set_name("name2");
+  modified_pref.mutable_preference()->set_name("name2");
   other_cryptographer.Encrypt(modified_pref,
                               modified_pref.mutable_encrypted());
   {
     // Mark bookmarks and preferences as encrypted and set the cryptographer to
     // have pending keys.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     sync_pb::EntitySpecifics specifics;
-    sync_pb::NigoriSpecifics* nigori =
-        specifics.MutableExtension(sync_pb::nigori);
+    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     other_cryptographer.GetKeys(nigori->mutable_encrypted());
     nigori->set_encrypt_bookmarks(true);
     nigori->set_encrypt_preferences(true);
     cryptographer(&wtrans)->Update(*nigori);
     EXPECT_TRUE(cryptographer(&wtrans)->has_pending_keys());
   }
 
   mock_server_->AddUpdateSpecifics(1, 0, "A", 10, 10, true, 0, bookmark);
   mock_server_->AddUpdateSpecifics(2, 1, "B", 10, 10, false, 2, bookmark);
   mock_server_->AddUpdateSpecifics(3, 1, "C", 10, 10, false, 1, bookmark);
@@ skipping 143 matching lines @@
 
 #undef VERIFY_ENTRY
 
 TEST_F(SyncerTest, NigoriConflicts) {
   KeyParams local_key_params = {"localhost", "dummy", "blargle"};
   KeyParams other_key_params = {"localhost", "dummy", "foobar"};
   browser_sync::Cryptographer other_cryptographer(&encryptor_);
   other_cryptographer.AddKey(other_key_params);
   syncable::ModelTypeSet encrypted_types(syncable::PASSWORDS, syncable::NIGORI);
   sync_pb::EntitySpecifics initial_nigori_specifics;
-  initial_nigori_specifics.MutableExtension(sync_pb::nigori);
+  initial_nigori_specifics.mutable_nigori();
   mock_server_->SetNigori(1, 10, 10, initial_nigori_specifics);
 
   // Data for testing encryption/decryption.
   sync_pb::EntitySpecifics other_encrypted_specifics;
-  other_encrypted_specifics.MutableExtension(sync_pb::bookmark)->
-      set_title("title");
+  other_encrypted_specifics.mutable_bookmark()->set_title("title");
   other_cryptographer.Encrypt(
       other_encrypted_specifics,
       other_encrypted_specifics.mutable_encrypted());
   sync_pb::EntitySpecifics our_encrypted_specifics;
-  our_encrypted_specifics.MutableExtension(sync_pb::bookmark)->
-      set_title("title2");
+  our_encrypted_specifics.mutable_bookmark()->set_title("title2");
 
   // Receive the initial nigori node.
   SyncShareAsDelegate();
   encrypted_types = syncable::ModelTypeSet::All();
   {
     // Local changes with different passphrase, different types, and sync_tabs.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     sync_pb::EntitySpecifics specifics;
-    sync_pb::NigoriSpecifics* nigori =
-        specifics.MutableExtension(sync_pb::nigori);
+    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     cryptographer(&wtrans)->AddKey(local_key_params);
     cryptographer(&wtrans)->Encrypt(
         our_encrypted_specifics,
         our_encrypted_specifics.mutable_encrypted());
     cryptographer(&wtrans)->GetKeys(
         nigori->mutable_encrypted());
     cryptographer(&wtrans)->UpdateNigoriFromEncryptedTypes(nigori);
     nigori->set_sync_tabs(true);
     cryptographer(&wtrans)->set_encrypt_everything();
     MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
                               syncable::ModelTypeToRootTag(syncable::NIGORI));
     ASSERT_TRUE(nigori_entry.good());
     nigori_entry.Put(SPECIFICS, specifics);
     nigori_entry.Put(IS_UNSYNCED, true);
     EXPECT_FALSE(cryptographer(&wtrans)->has_pending_keys());
     EXPECT_TRUE(encrypted_types.Equals(
             cryptographer(&wtrans)->GetEncryptedTypes()));
   }
   {
     sync_pb::EntitySpecifics specifics;
-    sync_pb::NigoriSpecifics* nigori =
-        specifics.MutableExtension(sync_pb::nigori);
+    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     other_cryptographer.GetKeys(nigori->mutable_encrypted());
     nigori->set_encrypt_bookmarks(true);
     nigori->set_encrypt_preferences(true);
     nigori->set_encrypt_everything(false);
     mock_server_->SetNigori(1, 20, 20, specifics);
   }
 
   // Will result in downloading the server nigori, which puts the local nigori
   // in a state of conflict. This is resolved by merging the local and server
   // data (with priority given to the server's encryption keys if they are
   // undecryptable), which we then commit. The cryptographer should have pending
   // keys and merge the set of encrypted types.
   SyncShareAsDelegate();  // Resolve conflict in this cycle.
   SyncShareAsDelegate();  // Commit local change in this cycle.
   {
     // Ensure the nigori data merged (encrypted types, sync_tabs).
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
                               syncable::ModelTypeToRootTag(syncable::NIGORI));
     ASSERT_TRUE(nigori_entry.good());
     EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
     sync_pb::EntitySpecifics specifics = nigori_entry.Get(SPECIFICS);
     EXPECT_TRUE(cryptographer(&wtrans)->has_pending_keys());
     EXPECT_TRUE(encrypted_types.Equals(
             cryptographer(&wtrans)->GetEncryptedTypes()));
     EXPECT_TRUE(cryptographer(&wtrans)->encrypt_everything());
-    EXPECT_TRUE(specifics.GetExtension(sync_pb::nigori).sync_tabs());
+    EXPECT_TRUE(specifics.nigori().sync_tabs());
     // Supply the pending keys. Afterwards, we should be able to decrypt both
     // our own encrypted data and data encrypted by the other cryptographer,
     // but the key provided by the other cryptographer should be the default.
     EXPECT_TRUE(cryptographer(&wtrans)->DecryptPendingKeys(other_key_params));
     EXPECT_FALSE(cryptographer(&wtrans)->has_pending_keys());
-    sync_pb::NigoriSpecifics* nigori =
-        specifics.MutableExtension(sync_pb::nigori);
+    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     cryptographer(&wtrans)->GetKeys(nigori->mutable_encrypted());
     cryptographer(&wtrans)->UpdateNigoriFromEncryptedTypes(nigori);
     // Normally this would be written as part of SetPassphrase, but we do it
     // manually for the test.
     nigori_entry.Put(SPECIFICS, specifics);
     nigori_entry.Put(IS_UNSYNCED, true);
   }
 
   SyncShareAsDelegate();
   {
     // Ensure everything is committed and stable now. The cryptographer
     // should be able to decrypt both sets of keys, sync_tabs should be true,
     // and the encrypted types should have been unioned.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
                               syncable::ModelTypeToRootTag(syncable::NIGORI));
     ASSERT_TRUE(nigori_entry.good());
     EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
     EXPECT_TRUE(cryptographer(&wtrans)->CanDecrypt(
         our_encrypted_specifics.encrypted()));
     EXPECT_FALSE(cryptographer(&wtrans)->
         CanDecryptUsingDefaultKey(our_encrypted_specifics.encrypted()));
     EXPECT_TRUE(cryptographer(&wtrans)->CanDecrypt(
         other_encrypted_specifics.encrypted()));
     EXPECT_TRUE(cryptographer(&wtrans)->
         CanDecryptUsingDefaultKey(other_encrypted_specifics.encrypted()));
-    EXPECT_TRUE(nigori_entry.Get(SPECIFICS).GetExtension(sync_pb::nigori)
-        .sync_tabs());
+    EXPECT_TRUE(nigori_entry.Get(SPECIFICS).nigori().sync_tabs());
   }
 }
 
 TEST_F(SyncerTest, TestGetUnsyncedAndSimpleCommit) {
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(),
                         "Pete");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
@@ skipping 1223 matching lines @@
   LoopSyncShare();
   syncable::Directory::ChildHandles children;
   {
     ReadTransaction trans(FROM_HERE, directory());
     directory()->GetChildHandlesById(&trans, parent_id_, &children);
     // We expect the conflict resolver to preserve the local entry.
     Entry child(&trans, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(child.good());
     EXPECT_TRUE(child.Get(syncable::IS_UNSYNCED));
     EXPECT_FALSE(child.Get(syncable::IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(child.Get(SPECIFICS).HasExtension(sync_pb::bookmark));
+    EXPECT_TRUE(child.Get(SPECIFICS).has_bookmark());
     EXPECT_EQ("Pete.htm", child.Get(NON_UNIQUE_NAME));
     VerifyTestBookmarkDataInEntry(&child);
   }
 
   // Only one entry, since we just overwrite one.
   EXPECT_EQ(1u, children.size());
   saw_syncer_event_ = false;
 }
 
 // We got this repro case when someone was editing bookmarks while sync was
@@ skipping 407 matching lines @@
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.Get(META_HANDLE) != server.Get(META_HANDLE));
     EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(server.Get(IS_UNSYNCED));
     EXPECT_FALSE(local.Get(IS_UNSYNCED));
     EXPECT_EQ("Bar.htm", server.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
-        server.Get(SPECIFICS).GetExtension(sync_pb::bookmark).url());
+        server.Get(SPECIFICS).bookmark().url());
   }
 }
 
 // Same as NewEntryAnddServerEntrySharePath, but using the old-style protocol.
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath_OldBookmarksProto) {
   mock_server_->set_use_legacy_bookmarks_protocol(true);
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10);
   SyncShareAsDelegate();
   int64 local_folder_handle;
   syncable::Id local_folder_id;
@@ skipping 45 matching lines @@
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.Get(META_HANDLE) != server.Get(META_HANDLE));
     EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(server.Get(IS_UNSYNCED));
     EXPECT_FALSE(local.Get(IS_UNSYNCED));
     EXPECT_EQ("Bar.htm", server.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
-        server.Get(SPECIFICS).GetExtension(sync_pb::bookmark).url());
+        server.Get(SPECIFICS).bookmark().url());
   }
 }
 
 // Circular links should be resolved by the server.
 TEST_F(SyncerTest, SiblingDirectoriesBecomeCircular) {
   // we don't currently resolve this. This test ensures we don't.
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   SyncShareAsDelegate();
   {
@@ skipping 707 matching lines @@
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
     EXPECT_EQ(perm_folder.Get(NON_UNIQUE_NAME), "permitem1");
   }
 }
 
 TEST_F(SyncerTest, ClientTagUncommittedTagMatchesUpdate) {
   int64 original_metahandle = 0;
 
   sync_pb::EntitySpecifics local_bookmark(DefaultBookmarkSpecifics());
-  local_bookmark.MutableExtension(sync_pb::bookmark)->
-      set_url("http://foo/localsite");
+  local_bookmark.mutable_bookmark()->set_url("http://foo/localsite");
   sync_pb::EntitySpecifics server_bookmark(DefaultBookmarkSpecifics());
-  server_bookmark.MutableExtension(sync_pb::bookmark)->
-      set_url("http://bar/serversite");
+  server_bookmark.mutable_bookmark()->set_url("http://bar/serversite");
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry perm_folder(&trans, CREATE, ids_.root(), "clientname");
     ASSERT_TRUE(perm_folder.good());
     perm_folder.Put(UNIQUE_CLIENT_TAG, "clientperm");
     perm_folder.Put(SPECIFICS, local_bookmark);
     perm_folder.Put(IS_UNSYNCED, true);
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(ID).ServerKnows());
@@ skipping 983 matching lines @@
   Add(low_id_);
   Add(high_id_);
   SyncShareAsDelegate();
   ExpectLocalOrderIsByServerId();
 }
 
 const SyncerTest::CommitOrderingTest
 SyncerTest::CommitOrderingTest::LAST_COMMIT_ITEM = {-1, TestIdFactory::root()};
 
 }  // namespace browser_sync