Refactor preference syncing.

chrome/browser/sync/profile_sync_service_preference_unittest.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 <map>
 #include <string>
 
 #include "base/json/json_reader.h"
 #include "base/stl_util-inl.h"
 #include "base/string_piece.h"
 #include "base/task.h"
+#include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 #include "chrome/browser/sync/engine/syncapi.h"
-#include "chrome/browser/sync/glue/preference_change_processor.h"
+#include "chrome/browser/sync/glue/generic_change_processor.h"
 #include "chrome/browser/sync/glue/preference_data_type_controller.h"
-#include "chrome/browser/sync/glue/preference_model_associator.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/protocol/preference_specifics.pb.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/testing_pref_service.h"
 #include "chrome/test/testing_profile.h"
 #include "content/common/json_value_serializer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONReader;
-using browser_sync::PreferenceChangeProcessor;
+using browser_sync::GenericChangeProcessor;
 using browser_sync::PreferenceDataTypeController;
-using browser_sync::PreferenceModelAssociator;
 using browser_sync::SyncBackendHost;
 using sync_api::SyncManager;
 using testing::_;
 using testing::Return;
 
 typedef std::map<const std::string, const Value*> PreferenceValues;
 
 class ProfileSyncServicePreferenceTest
     : public AbstractProfileSyncServiceTest {
  protected:
   ProfileSyncServicePreferenceTest()
       : example_url0_("http://example.com/0"),
         example_url1_("http://example.com/1"),
         example_url2_("http://example.com/2"),
         not_synced_preference_name_("nonsense_pref_name"),
         not_synced_preference_default_value_("default"),
         non_default_charset_value_("foo") {}
 
   virtual void SetUp() {
     AbstractProfileSyncServiceTest::SetUp();
     profile_.reset(new TestingProfile());
     profile_->CreateRequestContext();
     prefs_ = profile_->GetTestingPrefService();
 
     prefs_->RegisterStringPref(not_synced_preference_name_.c_str(),
-                               not_synced_preference_default_value_);
+                               not_synced_preference_default_value_,
+                               PrefService::UNSYNCABLE_PREF);
   }
 
   virtual void TearDown() {
     service_.reset();
     profile_.reset();
     AbstractProfileSyncServiceTest::TearDown();
   }
 
   bool StartSyncService(Task* task, bool will_fail_association) {
     if (service_.get())
       return false;
 
     service_.reset(new TestProfileSyncService(
         &factory_, profile_.get(), "test", false, task));
-
-    // Register the preference data type.
     model_associator_ =
-        new PreferenceModelAssociator(service_.get());
-    change_processor_ = new PreferenceChangeProcessor(model_associator_,
-                                                      service_.get());
+        reinterpret_cast<PrefModelAssociator*>(prefs_->GetSyncableService());
+    change_processor_ = new GenericChangeProcessor(model_associator_,
+                                                   service_.get());
     EXPECT_CALL(factory_, CreatePreferenceSyncComponents(_, _)).
         WillOnce(Return(ProfileSyncFactory::SyncComponents(
             model_associator_, change_processor_)));
 
     EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
         WillOnce(ReturnNewDataTypeManager());
 
-    service_->RegisterDataTypeController(
-        new PreferenceDataTypeController(&factory_,
-                                         profile_.get(),
-                                         service_.get()));
+    dtc_ = new PreferenceDataTypeController(&factory_,
+                                            profile_.get(),
+                                            service_.get());
+    service_->RegisterDataTypeController(dtc_);
     profile_->GetTokenService()->IssueAuthTokenForTest(
         GaiaConstants::kSyncService, "token");
+
     service_->Initialize();
     MessageLoop::current()->Run();
     return true;
   }
 
   const Value& GetPreferenceValue(const std::string& name) {
     const PrefService::Preference* preference =
         prefs_->FindPreference(name.c_str());
     return *preference->GetValue();
   }
@@ skipping 12 matching lines @@
     const sync_pb::PreferenceSpecifics& specifics(
         node.GetPreferenceSpecifics());
 
     JSONReader reader;
     return reader.JsonToValue(specifics.value(), false, false);
   }
 
   int64 WriteSyncedValue(const std::string& name,
                          const Value& value,
                          sync_api::WriteNode* node) {
-    if (!PreferenceModelAssociator::WritePreferenceToNode(name, value, node))
+    if (!PrefModelAssociator::WritePreferenceToNode(name, value, node))
       return sync_api::kInvalidId;
     return node->GetId();
   }
 
   int64 SetSyncedValue(const std::string& name, const Value& value) {
     sync_api::WriteTransaction trans(service_->GetUserShare());
     sync_api::ReadNode root(&trans);
-    if (!root.InitByTagLookup(browser_sync::kPreferencesTag))
+    if (!root.InitByTagLookup(
+        syncable::ModelTypeToRootTag(syncable::PREFERENCES))) {
       return sync_api::kInvalidId;
+    }
 
     sync_api::WriteNode tag_node(&trans);
     sync_api::WriteNode node(&trans);
 
     int64 node_id = model_associator_->GetSyncIdFromChromeId(name);
     if (node_id == sync_api::kInvalidId) {
       if (tag_node.InitByClientTagLookup(syncable::PREFERENCES, name))
         return WriteSyncedValue(name, value, &tag_node);
       if (node.InitUniqueByCreation(syncable::PREFERENCES, root, name))
         return WriteSyncedValue(name, value, &node);
@@ skipping 21 matching lines @@
     JSONStringValueSerializer json(&serialized);
     json.Serialize(value);
     return serialized;
   }
 
   friend class AddPreferenceEntriesTask;
 
   scoped_ptr<TestingProfile> profile_;
   TestingPrefService* prefs_;
 
-  PreferenceModelAssociator* model_associator_;
-  PreferenceChangeProcessor* change_processor_;
+  PreferenceDataTypeController* dtc_;
+  PrefModelAssociator* model_associator_;
+  GenericChangeProcessor* change_processor_;
+
   std::string example_url0_;
   std::string example_url1_;
   std::string example_url2_;
   std::string not_synced_preference_name_;
   std::string not_synced_preference_default_value_;
   std::string non_default_charset_value_;
 };
 
 class AddPreferenceEntriesTask : public Task {
  public:
@@ skipping 27 matching lines @@
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   const PrefService::Preference* pref =
       prefs_->FindPreference(prefs::kHomePage);
   sync_api::WriteTransaction trans(service_->GetUserShare());
   sync_api::WriteNode node(&trans);
   EXPECT_TRUE(node.InitByClientTagLookup(syncable::PREFERENCES,
                                          prefs::kHomePage));
 
-  EXPECT_TRUE(PreferenceModelAssociator::WritePreferenceToNode(
+  EXPECT_TRUE(PrefModelAssociator::WritePreferenceToNode(
       pref->name(), *pref->GetValue(), &node));
   EXPECT_EQ(UTF8ToWide(prefs::kHomePage), node.GetTitle());
   const sync_pb::PreferenceSpecifics& specifics(node.GetPreferenceSpecifics());
   EXPECT_EQ(std::string(prefs::kHomePage), specifics.name());
 
   base::JSONReader reader;
   scoped_ptr<Value> value(reader.JsonToValue(specifics.value(), false, false));
   EXPECT_TRUE(pref->GetValue()->Equals(value.get()));
 }
 
@@ skipping 250 matching lines @@
 
   // The pref value should still be the one dictated by policy.
   EXPECT_TRUE(managed_value->Equals(&GetPreferenceValue(prefs::kHomePage)));
 
   // Switch kHomePage back to unmanaged.
   profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
 
   // Sync value should be picked up.
   EXPECT_TRUE(sync_value->Equals(&GetPreferenceValue(prefs::kHomePage)));
 }