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

chrome/browser/sync/internal_api/write_node.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/internal_api/write_node.h"
 
 #include "base/json/json_writer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/sync/engine/nigori_util.h"
@@ skipping 55 matching lines @@
                << info;
     }
     // Only copy over the old specifics if it is of the right type and already
     // encrypted. The first time we encrypt a node we start from scratch, hence
     // removing all the unencrypted data, but from then on we only want to
     // update the node if the data changes or the encryption key changes.
     if (syncable::GetModelTypeFromSpecifics(old_specifics) == type &&
         was_encrypted) {
       generated_specifics.CopyFrom(old_specifics);
     } else {
-      syncable::AddDefaultExtensionValue(type, &generated_specifics);
+      syncable::AddDefaultFieldValue(type, &generated_specifics);
     }
     // Does not change anything if underlying encrypted blob was already up
     // to date and encrypted with the default key.
     if (!cryptographer->Encrypt(new_specifics,
                                 generated_specifics.mutable_encrypted())) {
       NOTREACHED() << "Could not encrypt data for node of type "
                    << syncable::ModelTypeToString(type);
       return false;
     }
   }
@@ skipping 13 matching lines @@
     return true;
   }
 
   if (generated_specifics.has_encrypted()) {
     // Overwrite the possibly sensitive non-specifics data.
     entry->Put(syncable::NON_UNIQUE_NAME, kEncryptedString);
     // For bookmarks we actually put bogus data into the unencrypted specifics,
     // else the server will try to do it for us.
     if (type == syncable::BOOKMARKS) {
       sync_pb::BookmarkSpecifics* bookmark_specifics =
-          generated_specifics.MutableExtension(sync_pb::bookmark);
+          generated_specifics.mutable_bookmark();
       if (!entry->Get(syncable::IS_DIR))
         bookmark_specifics->set_url(kEncryptedString);
       bookmark_specifics->set_title(kEncryptedString);
     }
   }
   entry->Put(syncable::SPECIFICS, generated_specifics);
   DVLOG(1) << "Overwriting specifics of type "
            << syncable::ModelTypeToString(type)
            << " and marking for syncing.";
   syncable::MarkForSyncing(entry);
@@ skipping 48 matching lines @@
   // necessary, nothing needs to change.
   if (title_matches && !encrypted_without_overwriting_name) {
     DVLOG(2) << "Title matches, dropping change.";
     return;
   }
 
   // For bookmarks, we also set the title field in the specifics.
   // TODO(zea): refactor bookmarks to not need this functionality.
   if (GetModelType() == syncable::BOOKMARKS) {
     sync_pb::EntitySpecifics specifics = GetEntitySpecifics();
-    specifics.MutableExtension(sync_pb::bookmark)->set_title(new_legal_title);
+    specifics.mutable_bookmark()->set_title(new_legal_title);
     SetEntitySpecifics(specifics);  // Does it's own encryption checking.
   }
 
   // For bookmarks, this has to happen after we set the title in the specifics,
   // because the presence of a title in the NON_UNIQUE_NAME is what controls
   // the logic deciding whether this is an empty node or a legacy bookmark.
   // See BaseNode::GetUnencryptedSpecific(..).
   if (needs_encryption)
     entry_->Put(syncable::NON_UNIQUE_NAME, kEncryptedString);
   else
     entry_->Put(syncable::NON_UNIQUE_NAME, new_legal_title);
 
   DVLOG(1) << "Overwriting title of type "
            << syncable::ModelTypeToString(type)
            << " and marking for syncing.";
   MarkForSyncing();
 }
 
 void WriteNode::SetURL(const GURL& url) {
   sync_pb::BookmarkSpecifics new_value = GetBookmarkSpecifics();
   new_value.set_url(url.spec());
   SetBookmarkSpecifics(new_value);
 }
 
 void WriteNode::SetAppSpecifics(
     const sync_pb::AppSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::app)->CopyFrom(new_value);
+  entity_specifics.mutable_app()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetAutofillSpecifics(
     const sync_pb::AutofillSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::autofill)->CopyFrom(new_value);
+  entity_specifics.mutable_autofill()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetAutofillProfileSpecifics(
     const sync_pb::AutofillProfileSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::autofill_profile)->
+  entity_specifics.mutable_autofill_profile()->
       CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetBookmarkSpecifics(
     const sync_pb::BookmarkSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::bookmark)->CopyFrom(new_value);
+  entity_specifics.mutable_bookmark()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetNigoriSpecifics(
     const sync_pb::NigoriSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::nigori)->CopyFrom(new_value);
+  entity_specifics.mutable_nigori()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetPasswordSpecifics(
     const sync_pb::PasswordSpecificsData& data) {
   DCHECK_EQ(syncable::PASSWORDS, GetModelType());
 
   Cryptographer* cryptographer = GetTransaction()->GetCryptographer();
 
   // We have to do the idempotency check here (vs in UpdateEntryWithEncryption)
   // because Passwords have their encrypted data within the PasswordSpecifics,
   // vs within the EntitySpecifics like all the other types.
   const sync_pb::EntitySpecifics& old_specifics = GetEntry()->Get(SPECIFICS);
   sync_pb::EntitySpecifics entity_specifics;
   // Copy over the old specifics if they exist.
   if (syncable::GetModelTypeFromSpecifics(old_specifics) ==
           syncable::PASSWORDS) {
     entity_specifics.CopyFrom(old_specifics);
   } else {
-    syncable::AddDefaultExtensionValue(syncable::PASSWORDS,
+    syncable::AddDefaultFieldValue(syncable::PASSWORDS,
                                        &entity_specifics);
   }
   sync_pb::PasswordSpecifics* password_specifics =
-      entity_specifics.MutableExtension(sync_pb::password);
+      entity_specifics.mutable_password();
   // This will only update password_specifics if the underlying unencrypted blob
   // was different from |data| or was not encrypted with the proper passphrase.
   if (!cryptographer->Encrypt(data, password_specifics->mutable_encrypted())) {
     NOTREACHED() << "Failed to encrypt password, possibly due to sync node "
                  << "corruption";
     return;
   }
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetThemeSpecifics(
     const sync_pb::ThemeSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::theme)->CopyFrom(new_value);
+  entity_specifics.mutable_theme()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetSessionSpecifics(
     const sync_pb::SessionSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::session)->CopyFrom(new_value);
+  entity_specifics.mutable_session()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetEntitySpecifics(
     const sync_pb::EntitySpecifics& new_value) {
   syncable::ModelType new_specifics_type =
       syncable::GetModelTypeFromSpecifics(new_value);
   DCHECK_NE(new_specifics_type, syncable::UNSPECIFIED);
   DVLOG(1) << "Writing entity specifics of type "
            << syncable::ModelTypeToString(new_specifics_type);
@@ skipping 29 matching lines @@
   DCHECK_EQ(new_specifics_type, GetModelType());
 }
 
 void WriteNode::ResetFromSpecifics() {
   SetEntitySpecifics(GetEntitySpecifics());
 }
 
 void WriteNode::SetTypedUrlSpecifics(
     const sync_pb::TypedUrlSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::typed_url)->CopyFrom(new_value);
+  entity_specifics.mutable_typed_url()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetExtensionSpecifics(
     const sync_pb::ExtensionSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::extension)->CopyFrom(new_value);
+  entity_specifics.mutable_extension()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetExternalId(int64 id) {
   if (GetExternalId() != id)
     entry_->Put(syncable::LOCAL_EXTERNAL_ID, id);
 }
 
 WriteNode::WriteNode(WriteTransaction* transaction)
     : entry_(NULL), transaction_(transaction) {
@@ skipping 42 matching lines @@
     return false;
   if (entry_->Get(syncable::IS_DEL))
     return false;
   syncable::ModelType model_type = GetModelType();
   DCHECK_EQ(syncable::NIGORI, model_type);
   return true;
 }
 
 void WriteNode::PutModelType(syncable::ModelType model_type) {
   // Set an empty specifics of the appropriate datatype.  The presence
-  // of the specific extension will identify the model type.
+  // of the specific field will identify the model type.
   DCHECK(GetModelType() == model_type ||
          GetModelType() == syncable::UNSPECIFIED);  // Immutable once set.
 
   sync_pb::EntitySpecifics specifics;
-  syncable::AddDefaultExtensionValue(model_type, &specifics);
+  syncable::AddDefaultFieldValue(model_type, &specifics);
   SetEntitySpecifics(specifics);
 }
 
 // Create a new node with default properties, and bind this WriteNode to it.
 // Return true on success.
 bool WriteNode::InitByCreation(syncable::ModelType model_type,
                                const BaseNode& parent,
                                const BaseNode* predecessor) {
   DCHECK(!entry_) << "Init called twice";
   // |predecessor| must be a child of |parent| or NULL.
@@ skipping 159 matching lines @@
   sync_pb::BookmarkSpecifics new_value = GetBookmarkSpecifics();
   new_value.set_favicon(bytes.empty() ? NULL : &bytes[0], bytes.size());
   SetBookmarkSpecifics(new_value);
 }
 
 void WriteNode::MarkForSyncing() {
   syncable::MarkForSyncing(entry_);
 }
 
 } // namespace sync_api