Implement new SyncAPI and convert Preferences to it.

chrome/browser/sync/engine/syncapi.cc

 // Copyright (c) 2011 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/syncapi.h"
 
 #include <algorithm>
 #include <bitset>
 #include <iomanip>
 #include <list>
@@ skipping 391 matching lines @@
       GetUnencryptedSpecifics(GetEntry());
   return unencrypted.GetExtension(sync_pb::nigori);
 }
 
 const sync_pb::PasswordSpecificsData& BaseNode::GetPasswordSpecifics() const {
   DCHECK_EQ(syncable::PASSWORDS, GetModelType());
   DCHECK(password_data_.get());
   return *password_data_;
 }
 
-const sync_pb::PreferenceSpecifics& BaseNode::GetPreferenceSpecifics() const {
-  DCHECK_EQ(syncable::PREFERENCES, GetModelType());
-  const sync_pb::EntitySpecifics& unencrypted =
-      GetUnencryptedSpecifics(GetEntry());
-  return unencrypted.GetExtension(sync_pb::preference);
-}
-
 const sync_pb::ThemeSpecifics& BaseNode::GetThemeSpecifics() const {
   DCHECK_EQ(syncable::THEMES, GetModelType());
   const sync_pb::EntitySpecifics& unencrypted =
       GetUnencryptedSpecifics(GetEntry());
   return unencrypted.GetExtension(sync_pb::theme);
 }
 
 const sync_pb::TypedUrlSpecifics& BaseNode::GetTypedUrlSpecifics() const {
   DCHECK_EQ(syncable::TYPED_URLS, GetModelType());
   const sync_pb::EntitySpecifics& unencrypted =
       GetUnencryptedSpecifics(GetEntry());
   return unencrypted.GetExtension(sync_pb::typed_url);
 }
 
 const sync_pb::ExtensionSpecifics& BaseNode::GetExtensionSpecifics() const {
   DCHECK_EQ(syncable::EXTENSIONS, GetModelType());
   const sync_pb::EntitySpecifics& unencrypted =
       GetUnencryptedSpecifics(GetEntry());
   return unencrypted.GetExtension(sync_pb::extension);
 }
 
 const sync_pb::SessionSpecifics& BaseNode::GetSessionSpecifics() const {
   DCHECK_EQ(syncable::SESSIONS, GetModelType());
   const sync_pb::EntitySpecifics& unencrypted =
       GetUnencryptedSpecifics(GetEntry());
   return unencrypted.GetExtension(sync_pb::session);
 }
 
+const sync_pb::EntitySpecifics& BaseNode::GetEntitySpecifics() const {
+  const sync_pb::EntitySpecifics& unencrypted =
+      GetUnencryptedSpecifics(GetEntry());
+  return unencrypted;
+}
+
 syncable::ModelType BaseNode::GetModelType() const {
   return GetEntry()->GetModelType();
 }
 
 ////////////////////////////////////
 // WriteNode member definitions
 void WriteNode::EncryptIfNecessary(sync_pb::EntitySpecifics* unencrypted) {
   syncable::ModelType type = syncable::GetModelTypeFromSpecifics(*unencrypted);
   DCHECK_NE(type, syncable::UNSPECIFIED);
   DCHECK_NE(type, syncable::PASSWORDS);  // Passwords use their own encryption.
@@ skipping 136 matching lines @@
     return;
   }
 
   sync_pb::PasswordSpecifics new_value;
   if (!cryptographer->Encrypt(data, new_value.mutable_encrypted())) {
     NOTREACHED();
   }
   PutPasswordSpecificsAndMarkForSyncing(new_value);
 }
 
-void WriteNode::SetPreferenceSpecifics(
-    const sync_pb::PreferenceSpecifics& new_value) {
-  DCHECK_EQ(syncable::PREFERENCES, GetModelType());
-  PutPreferenceSpecificsAndMarkForSyncing(new_value);
-}
-
 void WriteNode::SetThemeSpecifics(
     const sync_pb::ThemeSpecifics& new_value) {
   DCHECK_EQ(syncable::THEMES, GetModelType());
   PutThemeSpecificsAndMarkForSyncing(new_value);
 }
 
 void WriteNode::SetSessionSpecifics(
     const sync_pb::SessionSpecifics& new_value) {
   DCHECK_EQ(syncable::SESSIONS, GetModelType());
   PutSessionSpecificsAndMarkForSyncing(new_value);
 }
 
+void WriteNode::SetEntitySpecifics(
+    const sync_pb::EntitySpecifics& new_value) {
+  syncable::ModelType specifics_type =
+      syncable::GetModelTypeFromSpecifics(new_value);
+  DCHECK_EQ(specifics_type, GetModelType());
+  sync_pb::EntitySpecifics entity_specifics;
+  entity_specifics.CopyFrom(new_value);
+  EncryptIfNecessary(&entity_specifics);
+  PutSpecificsAndMarkForSyncing(entity_specifics);
+}
+
 void WriteNode::ResetFromSpecifics() {
   sync_pb::EntitySpecifics new_data;
   new_data.CopyFrom(GetUnencryptedSpecifics(GetEntry()));
   EncryptIfNecessary(&new_data);
   PutSpecificsAndMarkForSyncing(new_data);
 }
 
 void WriteNode::PutPasswordSpecificsAndMarkForSyncing(
     const sync_pb::PasswordSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.MutableExtension(sync_pb::password)->CopyFrom(new_value);
   PutSpecificsAndMarkForSyncing(entity_specifics);
 }
 
-void WriteNode::PutPreferenceSpecificsAndMarkForSyncing(
-    const sync_pb::PreferenceSpecifics& new_value) {
-  sync_pb::EntitySpecifics entity_specifics;
-  entity_specifics.MutableExtension(sync_pb::preference)->CopyFrom(new_value);
-  EncryptIfNecessary(&entity_specifics);
-  PutSpecificsAndMarkForSyncing(entity_specifics);
-}
-
 void WriteNode::SetTypedUrlSpecifics(
     const sync_pb::TypedUrlSpecifics& new_value) {
   DCHECK_EQ(syncable::TYPED_URLS, GetModelType());
   PutTypedUrlSpecificsAndMarkForSyncing(new_value);
 }
 
 void WriteNode::SetExtensionSpecifics(
     const sync_pb::ExtensionSpecifics& new_value) {
   DCHECK_EQ(syncable::EXTENSIONS, GetModelType());
   PutExtensionSpecificsAndMarkForSyncing(new_value);
@@ skipping 2356 matching lines @@
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 }  // namespace sync_api