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

chrome/browser/sync/engine/syncer_util.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/engine/syncer_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 262 matching lines @@
   // of the first client and commit the set of merged encryption keys. Until the
   // second client provides the pending passphrase, the cryptographer will
   // preserve the encryption keys based on the local passphrase, while the
   // nigori node will preserve the server encryption keys.
   //
   // If non-encryption changes are made to the nigori node, they will be
   // lost as part of conflict resolution. This is intended, as we place a higher
   // priority on preserving the server's passphrase change to preserving local
   // non-encryption changes. Next time the non-encryption changes are made to
   // the nigori node (e.g. on restart), they will commit without issue.
-  if (specifics.HasExtension(sync_pb::nigori)) {
-    const sync_pb::NigoriSpecifics& nigori =
-        specifics.GetExtension(sync_pb::nigori);
+  if (specifics.has_nigori()) {
+    const sync_pb::NigoriSpecifics& nigori = specifics.nigori();
     cryptographer->Update(nigori);
 
     // Make sure any unsynced changes are properly encrypted as necessary.
     // We only perform this if the cryptographer is ready. If not, these are
     // re-encrypted at SetPassphrase time (via ReEncryptEverything). This logic
     // covers the case where the nigori updated marked new datatypes for
     // encryption, but didn't change the passphrase.
     if (cryptographer->is_ready()) {
       // Note that we don't bother to encrypt any data for which IS_UNSYNCED
       // == false here. The machine that turned on encryption should know about
@@ skipping 17 matching lines @@
   // treated as an unresolvable conflict. See the description in syncer_types.h.
   // This prevents any unsynced changes from commiting and postpones conflict
   // resolution until all data can be decrypted.
   if (specifics.has_encrypted() &&
       !cryptographer->CanDecrypt(specifics.encrypted())) {
     // We can't decrypt this node yet.
     DVLOG(1) << "Received an undecryptable "
              << syncable::ModelTypeToString(entry->GetServerModelType())
              << " update, returning encryption_conflict.";
     return CONFLICT_ENCRYPTION;
-  } else if (specifics.HasExtension(sync_pb::password) &&
+  } else if (specifics.has_password() &&
              entry->Get(UNIQUE_SERVER_TAG).empty()) {
     // Passwords use their own legacy encryption scheme.
-    const sync_pb::PasswordSpecifics& password =
-        specifics.GetExtension(sync_pb::password);
+    const sync_pb::PasswordSpecifics& password = specifics.password();
     if (!cryptographer->CanDecrypt(password.encrypted())) {
       DVLOG(1) << "Received an undecryptable password update, returning "
                << "encryption_conflict.";
       return CONFLICT_ENCRYPTION;
     }
   }
 
   if (!entry->Get(SERVER_IS_DEL)) {
     syncable::Id new_parent = entry->Get(SERVER_PARENT_ID);
     Entry parent(trans, GET_BY_ID,  new_parent);
@@ skipping 51 matching lines @@
 // protocol.
 void UpdateBookmarkSpecifics(const std::string& singleton_tag,
                              const std::string& url,
                              const std::string& favicon_bytes,
                              MutableEntry* local_entry) {
   // In the new-style protocol, the server no longer sends bookmark info for
   // the "google_chrome" folder.  Mimic that here.
   if (singleton_tag == "google_chrome")
     return;
   sync_pb::EntitySpecifics pb;
-  sync_pb::BookmarkSpecifics* bookmark = pb.MutableExtension(sync_pb::bookmark);
+  sync_pb::BookmarkSpecifics* bookmark = pb.mutable_bookmark();
   if (!url.empty())
     bookmark->set_url(url);
   if (!favicon_bytes.empty())
     bookmark->set_favicon(favicon_bytes);
   local_entry->Put(SERVER_SPECIFICS, pb);
 }
 
 }  // namespace
 
 // Pass in name and checksum because of UTF8 conversion.
@@ skipping 361 matching lines @@
   if (update.version() < target->Get(SERVER_VERSION)) {
     LOG(WARNING) << "Update older than current server version for "
                  << *target << " Update:"
                  << SyncerProtoUtil::SyncEntityDebugString(update);
     return VERIFY_SUCCESS;  // Expected in new sync protocol.
   }
   return VERIFY_UNDECIDED;
 }
 
 }  // namespace browser_sync