sync: Implementation of Priority Preferences.

chrome/browser/sync/profile_sync_service_preference_unittest.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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 138 matching lines @@
     if (sync_service_)
       return false;
 
     SigninManager* signin = SigninManagerFactory::GetForProfile(profile_.get());
     signin->SetAuthenticatedUsername("test");
     sync_service_ = static_cast<TestProfileSyncService*>(
         ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             profile_.get(), &TestProfileSyncService::BuildAutoStartAsyncInit));
     sync_service_->set_backend_init_callback(callback);
     pref_sync_service_ = reinterpret_cast<PrefModelAssociator*>(
-        prefs_->GetSyncableService());
+        prefs_->GetSyncableService(syncer::PREFERENCES));
     if (!pref_sync_service_)
       return false;
     ProfileSyncComponentsFactoryMock* components =
         sync_service_->components_factory_mock();
     EXPECT_CALL(*components, GetSyncableServiceForType(syncer::PREFERENCES)).
         WillOnce(Return(pref_sync_service_->AsWeakPtr()));
 
     EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _)).
         WillOnce(ReturnNewDataTypeManagerWithDebugListener(
                      syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr())));
@@ skipping 46 matching lines @@
     const sync_pb::PreferenceSpecifics& specifics(
         node.GetEntitySpecifics().preference());
 
     return base::JSONReader::Read(specifics.value());
   }
 
   int64 WriteSyncedValue(const std::string& name,
                          const Value& value,
                          syncer::WriteNode* node) {
     syncer::SyncData sync_data;
-    if (!PrefModelAssociator::CreatePrefSyncData(name,
-                                                 value,
-                                                 &sync_data)) {
+    if (!pref_sync_service_->CreatePrefSyncData(name,
+                                                value,
+                                                &sync_data)) {
       return syncer::kInvalidId;
     }
     node->SetEntitySpecifics(sync_data.GetSpecifics());
     return node->GetId();
   }
 
   bool IsSynced(const std::string& pref_name) {
     return pref_sync_service_->registered_preferences().count(pref_name) > 0;
   }
 
@@ skipping 55 matching lines @@
 
 TEST_F(ProfileSyncServicePreferenceTest, CreatePrefSyncData) {
   prefs_->SetString(prefs::kHomePage, example_url0_);
   CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   const PrefService::Preference* pref =
       prefs_->FindPreference(prefs::kHomePage);
   syncer::SyncData sync_data;
-  EXPECT_TRUE(PrefModelAssociator::CreatePrefSyncData(pref->name(),
+  EXPECT_TRUE(pref_sync_service_->CreatePrefSyncData(pref->name(),
       *pref->GetValue(), &sync_data));
   EXPECT_EQ(std::string(prefs::kHomePage), sync_data.GetTag());
   const sync_pb::PreferenceSpecifics& specifics(sync_data.GetSpecifics().
       preference());
   EXPECT_EQ(std::string(prefs::kHomePage), specifics.name());
 
   scoped_ptr<Value> value(base::JSONReader::Read(specifics.value()));
   EXPECT_TRUE(pref->GetValue()->Equals(value.get()));
 }
 
@@ skipping 273 matching lines @@
 
 TEST_F(ProfileSyncServicePreferenceTest, DynamicManagedPreferences) {
   CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> initial_value(
       Value::CreateStringValue("http://example.com/initial"));
   profile_->GetPrefs()->Set(prefs::kHomePage, *initial_value);
   scoped_ptr<const Value> actual(GetSyncedValue(prefs::kHomePage));
+  ASSERT_TRUE(actual.get());
   EXPECT_TRUE(initial_value->Equals(actual.get()));
 
   // Switch kHomePage to managed and set a different value.
   scoped_ptr<Value> managed_value(
       Value::CreateStringValue("http://example.com/managed"));
   profile_->GetTestingPrefService()->SetManagedPref(
       prefs::kHomePage, managed_value->DeepCopy());
 
   // The pref value should be the one dictated by policy.
   EXPECT_TRUE(managed_value->Equals(&GetPreferenceValue(prefs::kHomePage)));
@@ skipping 67 matching lines @@
   EXPECT_FALSE(pref->IsDefaultValue());
   // There should be no synced value.
   EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL);
   // Switch kHomePage back to unmanaged.
   profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
   // The original value should be picked up.
   EXPECT_TRUE(pref->IsDefaultValue());
   // There should still be no synced value.
   EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL);
 }