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

chrome/browser/prefs/pref_model_associator.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/prefs/pref_model_associator.h"
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/sync/api/sync_change.h"
 #include "chrome/browser/sync/protocol/preference_specifics.pb.h"
+#include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 
 using syncable::PREFERENCES;
 
 PrefModelAssociator::PrefModelAssociator()
     : models_associated_(false),
       processing_syncer_changes_(false),
       pref_service_(NULL),
       sync_processor_(NULL) {
@@ skipping 13 matching lines @@
   const PrefService::Preference* pref =
       pref_service_->FindPreference(pref_name.c_str());
   DCHECK(pref);
   VLOG(1) << "Associating preference " << pref_name;
 
   base::JSONReader reader;
   if (sync_pref.IsValid()) {
     // The server has a value for the preference, we have to reconcile it with
     // ours.
     const sync_pb::PreferenceSpecifics& preference =
-        sync_pref.GetSpecifics().GetExtension(sync_pb::preference);
+        sync_pref.GetSpecifics().preference();
     DCHECK_EQ(pref->name(), preference.name());
 
     scoped_ptr<Value> value(
         reader.JsonToValue(preference.value(), false, false));
     if (!value.get()) {
       LOG(ERROR) << "Failed to deserialize preference value: "
                  << reader.GetErrorMessage();
       return;
     }
 
@@ skipping 57 matching lines @@
 
   SyncChangeList new_changes;
   std::set<std::string> remaining_preferences = registered_preferences_;
 
   // Go through and check for all preferences we care about that sync already
   // knows about.
   for (SyncDataList::const_iterator sync_iter = initial_sync_data.begin();
        sync_iter != initial_sync_data.end();
        ++sync_iter) {
     DCHECK_EQ(PREFERENCES, sync_iter->GetDataType());
-    std::string sync_pref_name = sync_iter->GetSpecifics().
-        GetExtension(sync_pb::preference).name();
+    std::string sync_pref_name = sync_iter->GetSpecifics().preference().name();
     if (remaining_preferences.count(sync_pref_name) == 0) {
       // We're not syncing this preference locally, ignore the sync data.
       // TODO(zea): Eventually we want to be able to have the syncable service
       // reconstruct all sync data for it's datatype (therefore having
       // GetAllSyncData be a complete representation). We should store this data
       // somewhere, even if we don't use it.
       continue;
     }
 
     remaining_preferences.erase(sync_pref_name);
@@ skipping 52 matching lines @@
   std::string serialized;
   // TODO(zea): consider JSONWriter::Write since you don't have to check
   // failures to deserialize.
   JSONStringValueSerializer json(&serialized);
   if (!json.Serialize(value)) {
     LOG(ERROR) << "Failed to serialize preference value.";
     return false;
   }
 
   sync_pb::EntitySpecifics specifics;
-  sync_pb::PreferenceSpecifics* pref_specifics = specifics.MutableExtension(
-      sync_pb::preference);
+  sync_pb::PreferenceSpecifics* pref_specifics = specifics.mutable_preference();
   pref_specifics->set_name(name);
   pref_specifics->set_value(serialized);
   *sync_data = SyncData::CreateLocalData(name, name, specifics);
   return true;
 }
 
 Value* PrefModelAssociator::MergeListValues(const Value& from_value,
                                             const Value& to_value) {
   if (from_value.GetType() == Value::TYPE_NULL)
     return to_value.DeepCopy();
@@ skipping 86 matching lines @@
                     PREFERENCES);
     return error;
   }
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
   SyncChangeList::const_iterator iter;
   for (iter = change_list.begin(); iter != change_list.end(); ++iter) {
     DCHECK_EQ(PREFERENCES, iter->sync_data().GetDataType());
 
     std::string name;
     sync_pb::PreferenceSpecifics pref_specifics =
-        iter->sync_data().GetSpecifics().GetExtension(sync_pb::preference);
+        iter->sync_data().GetSpecifics().preference();
     scoped_ptr<Value> value(ReadPreferenceSpecifics(pref_specifics,
                                                     &name));
 
     if (iter->change_type() == SyncChange::ACTION_DELETE) {
       // We never delete preferences.
       NOTREACHED() << "Attempted to process sync delete change for " << name
                    << ". Skipping.";
       continue;
     }
 
@@ skipping 107 matching lines @@
   SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
   if (error.IsSet())
     StopSyncing(PREFERENCES);
 }
 
 void PrefModelAssociator::SetPrefService(PrefService* pref_service) {
   DCHECK(pref_service_ == NULL);
   pref_service_ = pref_service;
 }