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

chrome/browser/sync/syncable/syncable_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.
 
 #include "chrome/browser/sync/syncable/syncable.h"
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 46 matching lines @@
     ADD_FAILURE();
   }
 }
 
 namespace {
 void PutDataAsBookmarkFavicon(WriteTransaction* wtrans,
                               MutableEntry* e,
                               const char* bytes,
                               size_t bytes_length) {
   sync_pb::EntitySpecifics specifics;
-  specifics.MutableExtension(sync_pb::bookmark)->set_url("http://demo/");
-  specifics.MutableExtension(sync_pb::bookmark)->set_favicon(bytes,
-      bytes_length);
+  specifics.mutable_bookmark()->set_url("http://demo/");
+  specifics.mutable_bookmark()->set_favicon(bytes, bytes_length);
   e->Put(SPECIFICS, specifics);
 }
 
 void ExpectDataFromBookmarkFaviconEquals(BaseTransaction* trans,
                                          Entry* e,
                                          const char* bytes,
                                          size_t bytes_length) {
   ASSERT_TRUE(e->good());
-  ASSERT_TRUE(e->Get(SPECIFICS).HasExtension(sync_pb::bookmark));
-  ASSERT_EQ("http://demo/",
-      e->Get(SPECIFICS).GetExtension(sync_pb::bookmark).url());
+  ASSERT_TRUE(e->Get(SPECIFICS).has_bookmark());
+  ASSERT_EQ("http://demo/", e->Get(SPECIFICS).bookmark().url());
   ASSERT_EQ(std::string(bytes, bytes_length),
-      e->Get(SPECIFICS).GetExtension(sync_pb::bookmark).favicon());
+            e->Get(SPECIFICS).bookmark().favicon());
 }
 }  // namespace
 
 class SyncableGeneralTest : public testing::Test {
  public:
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     db_path_ = temp_dir_.path().Append(
         FILE_PATH_LITERAL("SyncableTest.sqlite3"));
   }
@@ skipping 431 matching lines @@
   const int metas_to_create = 50;
   MetahandleSet expected_purges;
   MetahandleSet all_handles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     for (int i = 0; i < metas_to_create; i++) {
       MutableEntry e(&trans, CREATE, trans.root_id(), "foo");
       e.Put(IS_UNSYNCED, true);
       sync_pb::EntitySpecifics specs;
       if (i % 2 == 0) {
-        AddDefaultExtensionValue(BOOKMARKS, &specs);
+        AddDefaultFieldValue(BOOKMARKS, &specs);
         expected_purges.insert(e.Get(META_HANDLE));
         all_handles.insert(e.Get(META_HANDLE));
       } else {
-        AddDefaultExtensionValue(PREFERENCES, &specs);
+        AddDefaultFieldValue(PREFERENCES, &specs);
         all_handles.insert(e.Get(META_HANDLE));
       }
       e.Put(SPECIFICS, specs);
       e.Put(SERVER_SPECIFICS, specs);
     }
   }
 
   syncable::ModelTypeSet to_purge(BOOKMARKS);
   dir_->PurgeEntriesWithTypeIn(to_purge);
 
@@ skipping 70 matching lines @@
       EXPECT_TRUE(i->is_dirty());
     }
     dir_->VacuumAfterSaveChanges(snapshot);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestPurgeEntriesWithTypeIn) {
   sync_pb::EntitySpecifics bookmark_specs;
   sync_pb::EntitySpecifics autofill_specs;
   sync_pb::EntitySpecifics preference_specs;
-  AddDefaultExtensionValue(BOOKMARKS, &bookmark_specs);
-  AddDefaultExtensionValue(PREFERENCES, &preference_specs);
-  AddDefaultExtensionValue(AUTOFILL, &autofill_specs);
+  AddDefaultFieldValue(BOOKMARKS, &bookmark_specs);
+  AddDefaultFieldValue(PREFERENCES, &preference_specs);
+  AddDefaultFieldValue(AUTOFILL, &autofill_specs);
   dir_->set_initial_sync_ended_for_type(BOOKMARKS, true);
   dir_->set_initial_sync_ended_for_type(PREFERENCES, true);
   dir_->set_initial_sync_ended_for_type(AUTOFILL, true);
 
   syncable::ModelTypeSet types_to_purge(PREFERENCES, AUTOFILL);
 
   TestIdFactory id_factory;
   // Create some items for each type.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
@@ skipping 551 matching lines @@
   EntryKernel create_post_save, update_post_save;
   std::string create_name =  "Create";
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     MutableEntry create(&trans, CREATE, trans.root_id(), create_name);
     MutableEntry update(&trans, CREATE_NEW_UPDATE_ITEM, update_id);
     create.Put(IS_UNSYNCED, true);
     update.Put(IS_UNAPPLIED_UPDATE, true);
     sync_pb::EntitySpecifics specifics;
-    specifics.MutableExtension(sync_pb::bookmark)->set_favicon("PNG");
-    specifics.MutableExtension(sync_pb::bookmark)->set_url("http://nowhere");
+    specifics.mutable_bookmark()->set_favicon("PNG");
+    specifics.mutable_bookmark()->set_url("http://nowhere");
     create.Put(SPECIFICS, specifics);
     create_pre_save = create.GetKernelCopy();
     update_pre_save = update.GetKernelCopy();
     create_id = create.Get(ID);
   }
 
   dir_->SaveChanges();
   dir_.reset(new Directory(&encryptor_, &handler_, NULL));
   ASSERT_TRUE(dir_.get());
   ASSERT_EQ(OPENED, dir_->Open(file_path_, kName,
@@ skipping 150 matching lines @@
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     MutableEntry e1(&trans, CREATE, trans.root_id(), "aguilera");
     ASSERT_TRUE(e1.good());
     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(BASE_VERSION, 1);
     e1.Put(IS_DIR, true);
     e1.Put(ID, TestIdFactory::FromNumber(101));
     sync_pb::EntitySpecifics bookmark_specs;
-    AddDefaultExtensionValue(BOOKMARKS, &bookmark_specs);
+    AddDefaultFieldValue(BOOKMARKS, &bookmark_specs);
     e1.Put(SPECIFICS, bookmark_specs);
     e1.Put(SERVER_SPECIFICS, bookmark_specs);
     e1.Put(ID, TestIdFactory::FromNumber(101));
     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
   }
   ASSERT_TRUE(dir_->SaveChanges());
 
   // Now do some operations using a directory for which SaveChanges will
   // always fail.
@@ skipping 18 matching lines @@
     ModelType datatype = ModelTypeFromInt(i);
     SCOPED_TRACE(testing::Message("Testing model type ") << datatype);
     switch (datatype) {
       case UNSPECIFIED:
       case TOP_LEVEL_FOLDER:
         continue;  // Datatype isn't a function of Specifics.
       default:
         break;
     }
     sync_pb::EntitySpecifics specifics;
-    AddDefaultExtensionValue(datatype, &specifics);
+    AddDefaultFieldValue(datatype, &specifics);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     MutableEntry folder(&trans, CREATE, trans.root_id(), "Folder");
     ASSERT_TRUE(folder.good());
     folder.Put(ID, id_factory.NewServerId());
     folder.Put(SPECIFICS, specifics);
     folder.Put(BASE_VERSION, 1);
     folder.Put(IS_DIR, true);
     folder.Put(IS_DEL, false);
@@ skipping 265 matching lines @@
 TEST_F(SyncableClientTagTest, TestClientTagIndexDuplicateServer) {
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable