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 31 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONReader;
 using browser_sync::GenericChangeProcessor;
 using browser_sync::SharedChangeProcessor;
 using browser_sync::UIDataTypeController;
 using syncer::ChangeRecord;
 using testing::_;
 using testing::Invoke;
 using testing::Return;
+using testing::Values;
 
 typedef std::map<const std::string, const Value*> PreferenceValues;
 
 ACTION_P(CreateAndSaveChangeProcessor, change_processor) {
   syncer::UserShare* user_share = arg0->GetUserShare();
   *change_processor = new GenericChangeProcessor(arg1,
                                                  arg2,
                                                  arg3,
                                                  user_share);
   return *change_processor;
 }
 
 ACTION_P(ReturnNewDataTypeManagerWithDebugListener, debug_listener) {
   return new browser_sync::DataTypeManagerImpl(
       debug_listener,
       arg1,
       arg2,
       arg3,
       arg4);
 }
 
 // TODO(zea): Refactor to remove the ProfileSyncService usage.
 class ProfileSyncServicePreferenceTest
-    : public AbstractProfileSyncServiceTest,
-      public syncer::DataTypeDebugInfoListener {
+    : public BaseProfileSyncServiceTest,
+      public syncer::DataTypeDebugInfoListener,
+      public ::testing::TestWithParam<syncer::ModelType> {
  public:
+
   int64 SetSyncedValue(const std::string& name, const Value& value) {
     syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode root(&trans);
     if (root.InitByTagLookup(syncer::ModelTypeToRootTag(
             syncer::PREFERENCES)) != syncer::BaseNode::INIT_OK) {
       return syncer::kInvalidId;
     }
 
     syncer::WriteNode tag_node(&trans);
     syncer::WriteNode node(&trans);
@@ skipping 15 matching lines @@
   virtual void OnDataTypeAssociationComplete(
       const syncer::DataTypeAssociationStats& association_stats) OVERRIDE {
     association_stats_ = association_stats;
   }
   virtual void OnConfigureComplete() OVERRIDE {
     // Do nothing.
   }
 
  protected:
   ProfileSyncServicePreferenceTest()
-      : debug_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      : BaseProfileSyncServiceTest(),
+        debug_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         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();
+    type_ = GetParam();
+    BaseProfileSyncServiceTest::SetUp();
     profile_.reset(new TestingProfile());
     profile_->CreateRequestContext();
     prefs_ = profile_->GetTestingPrefService();
 
     prefs_->registry()->RegisterStringPref(
         not_synced_preference_name_.c_str(),
         not_synced_preference_default_value_,
         PrefRegistrySyncable::UNSYNCABLE_PREF);
   }
 
   virtual void TearDown() {
     profile_.reset();
-    AbstractProfileSyncServiceTest::TearDown();
+    BaseProfileSyncServiceTest::TearDown();
   }
 
   int GetSyncPreferenceCount() {
     syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode node(&trans);
     if (node.InitByTagLookup(syncer::ModelTypeToRootTag(syncer::PREFERENCES)) !=
         syncer::BaseNode::INIT_OK)
       return 0;
     return node.GetTotalNodeCount() - 1;
   }
 
   bool StartSyncService(const base::Closure& callback,
                         bool will_fail_association) {
     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(type_));
     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;
   }
 
   std::string ValueString(const Value& value) {
     std::string serialized;
     JSONStringValueSerializer json(&serialized);
     json.Serialize(value);
     return serialized;
   }
 
+  syncer::ModelType type_;
   scoped_ptr<TestingProfile> profile_;
   TestingPrefServiceSyncable* prefs_;
 
   UIDataTypeController* dtc_;
   PrefModelAssociator* pref_sync_service_;
   GenericChangeProcessor* change_processor_;
   syncer::DataTypeAssociationStats association_stats_;
   base::WeakPtrFactory<DataTypeDebugInfoListener> debug_ptr_factory_;
 
   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_;
 };
 
+INSTANTIATE_TEST_CASE_P(MeaningfulTestParameters,
+                        ProfileSyncServicePreferenceTest,
+                        Values(syncer::PREFERENCES,
+                               syncer::PRIORITY_PREFERENCES));
+
 class AddPreferenceEntriesHelper {
  public:
   AddPreferenceEntriesHelper(ProfileSyncServicePreferenceTest* test,
                              const PreferenceValues& entries)
       : ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
             base::Bind(
                 &AddPreferenceEntriesHelper::AddPreferenceEntriesCallback,
                 base::Unretained(this), test, entries))),
         success_(false) {
   }
@@ skipping 21 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 360 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);
 }