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

chrome/browser/sync/engine/apply_updates_command_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 <string>
 
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/sync/engine/apply_updates_command.h"
@@ skipping 19 matching lines @@
 using syncable::Entry;
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::ReadTransaction;
 using syncable::UNITTEST;
 using syncable::WriteTransaction;
 
 namespace {
 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
   sync_pb::EntitySpecifics result;
-  AddDefaultExtensionValue(syncable::BOOKMARKS, &result);
+  AddDefaultFieldValue(syncable::BOOKMARKS, &result);
   return result;
 }
 } // namespace
 
 // A test fixture for tests exercising ApplyUpdatesCommand.
 class ApplyUpdatesCommandTest : public SyncerCommandTest {
  public:
  protected:
   ApplyUpdatesCommandTest() : next_revision_(1) {}
   virtual ~ApplyUpdatesCommandTest() {}
@@ skipping 66 matching lines @@
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::ID, item_id);
     entry.Put(syncable::BASE_VERSION,
         item_id.ServerKnows() ? next_revision_++ : 0);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::IS_DIR, is_folder);
     entry.Put(syncable::IS_DEL, false);
     entry.Put(syncable::PARENT_ID, parent_id);
     CHECK(entry.PutPredecessor(predecessor_id));
     sync_pb::EntitySpecifics default_specifics;
-    syncable::AddDefaultExtensionValue(model_type, &default_specifics);
+    syncable::AddDefaultFieldValue(model_type, &default_specifics);
     entry.Put(syncable::SPECIFICS, default_specifics);
     if (item_id.ServerKnows()) {
       entry.Put(syncable::SERVER_SPECIFICS, default_specifics);
       entry.Put(syncable::SERVER_IS_DIR, is_folder);
       entry.Put(syncable::SERVER_PARENT_ID, parent_id);
       entry.Put(syncable::SERVER_IS_DEL, false);
     }
     if (metahandle_out)
       *metahandle_out = entry.Get(syncable::META_HANDLE);
   }
@@ skipping 25 matching lines @@
   // the created item.
   int64 CreateSyncedItem(const std::string& name, syncable::ModelType
                          model_type, bool is_folder) {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
     syncable::Id parent_id(id_factory_.root());
     syncable::Id item_id(id_factory_.MakeServer(name));
     int64 version = GetNextRevision();
 
     sync_pb::EntitySpecifics default_specifics;
-    syncable::AddDefaultExtensionValue(model_type, &default_specifics);
+    syncable::AddDefaultFieldValue(model_type, &default_specifics);
 
     MutableEntry entry(&trans, syncable::CREATE, parent_id, name);
     if (!entry.good()) {
       ADD_FAILURE();
       return syncable::kInvalidMetaHandle;
     }
 
     entry.Put(syncable::ID, item_id);
     entry.Put(syncable::BASE_VERSION, version);
     entry.Put(syncable::IS_UNSYNCED, false);
@@ skipping 347 matching lines @@
   }
 
   browser_sync::KeyParams params = {"localhost", "dummy", "foobar"};
   cryptographer->AddKey(params);
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::PasswordSpecificsData data;
   data.set_origin("http://example.com");
 
   cryptographer->Encrypt(data,
-      specifics.MutableExtension(sync_pb::password)->mutable_encrypted());
+                         specifics.mutable_password()->mutable_encrypted());
   CreateUnappliedNewItem("item", specifics, false);
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSWORD);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSWORD);
   ASSERT_TRUE(status->update_progress());
   EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
       << "No update should be in conflict because they're all decryptable";
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The updates that can be decrypted should be applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, UndecryptableData) {
   // Undecryptable updates should not be applied.
   sync_pb::EntitySpecifics encrypted_bookmark;
   encrypted_bookmark.mutable_encrypted();
-  AddDefaultExtensionValue(syncable::BOOKMARKS, &encrypted_bookmark);
+  AddDefaultFieldValue(syncable::BOOKMARKS, &encrypted_bookmark);
   string root_server_id = syncable::GetNullId().GetServerId();
   CreateUnappliedNewItemWithParent("folder",
                                    encrypted_bookmark,
                                    root_server_id);
   CreateUnappliedNewItem("item2", encrypted_bookmark, false);
   sync_pb::EntitySpecifics encrypted_password;
-  encrypted_password.MutableExtension(sync_pb::password);
+  encrypted_password.mutable_password();
   CreateUnappliedNewItem("item3", encrypted_password, false);
 
   ExpectGroupsToChange(apply_updates_command_, GROUP_UI, GROUP_PASSWORD);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   EXPECT_TRUE(status->HasConflictingUpdates())
     << "Updates that can't be decrypted should trigger the syncer to have "
     << "conflicting updates.";
   {
@@ skipping 35 matching lines @@
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/1");
     {
       ReadTransaction trans(FROM_HERE, directory());
       Cryptographer* cryptographer = directory()->GetCryptographer(&trans);
 
       KeyParams params = {"localhost", "dummy", "foobar"};
       cryptographer->AddKey(params);
 
       cryptographer->Encrypt(data,
-          specifics.MutableExtension(sync_pb::password)->mutable_encrypted());
+          specifics.mutable_password()->mutable_encrypted());
     }
     CreateUnappliedNewItem("item1", specifics, false);
   }
   {
     // Create a new cryptographer, independent of the one in the session.
     Cryptographer cryptographer(&encryptor_);
     KeyParams params = {"localhost", "dummy", "bazqux"};
     cryptographer.AddKey(params);
 
     sync_pb::EntitySpecifics specifics;
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/2");
 
     cryptographer.Encrypt(data,
-        specifics.MutableExtension(sync_pb::password)->mutable_encrypted());
+        specifics.mutable_password()->mutable_encrypted());
     CreateUnappliedNewItem("item2", specifics, false);
   }
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSWORD);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   EXPECT_TRUE(status->HasConflictingUpdates())
     << "Updates that can't be decrypted should trigger the syncer to have "
     << "conflicting updates.";
@@ skipping 26 matching lines @@
     cryptographer = directory()->GetCryptographer(&trans);
     EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
   }
 
   // Nigori node updates should update the Cryptographer.
   Cryptographer other_cryptographer(&encryptor_);
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(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);
   encrypted_types.Put(syncable::BOOKMARKS);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
   apply_updates_command_.ExecuteImpl(session());
 
@@ skipping 27 matching lines @@
     cryptographer = directory()->GetCryptographer(&trans);
     EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
   }
 
   // Nigori node updates should update the Cryptographer.
   Cryptographer other_cryptographer(&encryptor_);
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(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_sessions(true);
   nigori->set_encrypt_themes(true);
   encrypted_types.Put(syncable::SESSIONS);
   encrypted_types.Put(syncable::THEMES);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
@@ skipping 58 matching lines @@
   // Next five items are children of the root.
   for (; i < 2*batch_s; ++i) {
     CreateUnsyncedItem(id_factory_.NewLocalId(), id_factory_.root(),
                        base::StringPrintf("Item %"PRIuS"", i), false,
                        syncable::BOOKMARKS, NULL);
   }
 
   KeyParams params = {"localhost", "dummy", "foobar"};
   cryptographer->AddKey(params);
   sync_pb::EntitySpecifics specifics;
-  sync_pb::NigoriSpecifics* nigori =
-      specifics.MutableExtension(sync_pb::nigori);
+  sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
   cryptographer->GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
   encrypted_types.Put(syncable::BOOKMARKS);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
 
   {
     // Ensure we have unsynced nodes that aren't properly encrypted.
@@ skipping 118 matching lines @@
                        base::StringPrintf("Item %"PRIuS"", i), false,
                        syncable::BOOKMARKS, NULL);
   }
 
   // We encrypt with new keys, triggering the local cryptographer to be unready
   // and unable to decrypt data (once updated).
   Cryptographer other_cryptographer(&encryptor_);
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(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);
   encrypted_types.Put(syncable::BOOKMARKS);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   {
     // Ensure we have unsynced nodes that aren't properly encrypted.
     ReadTransaction trans(FROM_HERE, directory());
@@ skipping 33 matching lines @@
     EXPECT_FALSE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->has_pending_keys());
 
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 }  // namespace browser_sync