[Sync] Move ModelType and related classes to 'syncer' namespace

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 45 matching lines @@
   return *change_processor;
 }
 
 // TODO(zea): Refactor to remove the ProfileSyncService usage.
 class ProfileSyncServicePreferenceTest
     : public AbstractProfileSyncServiceTest {
  public:
   int64 SetSyncedValue(const std::string& name, const Value& value) {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     syncer::ReadNode root(&trans);
-    if (root.InitByTagLookup(syncable::ModelTypeToRootTag(
-            syncable::PREFERENCES)) != syncer::BaseNode::INIT_OK) {
+    if (root.InitByTagLookup(syncer::ModelTypeToRootTag(
+            syncer::PREFERENCES)) != syncer::BaseNode::INIT_OK) {
       return syncer::kInvalidId;
     }
 
     syncer::WriteNode tag_node(&trans);
     syncer::WriteNode node(&trans);
 
-    if (tag_node.InitByClientTagLookup(syncable::PREFERENCES, name) ==
+    if (tag_node.InitByClientTagLookup(syncer::PREFERENCES, name) ==
             syncer::BaseNode::INIT_OK) {
       return WriteSyncedValue(name, value, &tag_node);
     }
 
     syncer::WriteNode::InitUniqueByCreationResult result =
-        node.InitUniqueByCreation(syncable::PREFERENCES, root, name);
+        node.InitUniqueByCreation(syncer::PREFERENCES, root, name);
     if (result == syncer::WriteNode::INIT_SUCCESS)
       return WriteSyncedValue(name, value, &node);
 
     return syncer::kInvalidId;
   }
 
  protected:
   ProfileSyncServicePreferenceTest()
       : example_url0_("http://example.com/0"),
         example_url1_("http://example.com/1"),
@@ skipping 32 matching lines @@
         factory,
         profile_.get(),
         signin,
         ProfileSyncService::AUTO_START,
         false,
         callback));
     pref_sync_service_ = reinterpret_cast<PrefModelAssociator*>(
         prefs_->GetSyncableService());
     if (!pref_sync_service_)
       return false;
-    EXPECT_CALL(*factory, GetSyncableServiceForType(syncable::PREFERENCES)).
+    EXPECT_CALL(*factory, GetSyncableServiceForType(syncer::PREFERENCES)).
         WillOnce(Return(pref_sync_service_->AsWeakPtr()));
 
     EXPECT_CALL(*factory, CreateDataTypeManager(_, _)).
         WillOnce(ReturnNewDataTypeManager());
-    dtc_ = new UIDataTypeController(syncable::PREFERENCES,
+    dtc_ = new UIDataTypeController(syncer::PREFERENCES,
                                     factory,
                                     profile_.get(),
                                     service_.get());
     EXPECT_CALL(*factory, CreateSharedChangeProcessor()).
         WillOnce(Return(new SharedChangeProcessor()));
     EXPECT_CALL(*factory, CreateGenericChangeProcessor(_, _, _)).
         WillOnce(CreateAndSaveChangeProcessor(&change_processor_));
     service_->RegisterDataTypeController(dtc_);
     TokenServiceFactory::GetForProfile(profile_.get())->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();
   }
 
   // Caller gets ownership of the returned value.
   const Value* GetSyncedValue(const std::string& name) {
     syncer::ReadTransaction trans(FROM_HERE, service_->GetUserShare());
     syncer::ReadNode node(&trans);
 
-    if (node.InitByClientTagLookup(syncable::PREFERENCES, name) !=
+    if (node.InitByClientTagLookup(syncer::PREFERENCES, name) !=
             syncer::BaseNode::INIT_OK) {
       return NULL;
     }
 
     const sync_pb::PreferenceSpecifics& specifics(
         node.GetEntitySpecifics().preference());
 
     return base::JSONReader::Read(specifics.value());
   }
 
@@ skipping 46 matching lines @@
                 base::Unretained(this), test, entries))),
         success_(false) {
   }
 
   const base::Closure& callback() const { return callback_; }
   bool success() { return success_; }
 
  private:
   void AddPreferenceEntriesCallback(ProfileSyncServicePreferenceTest* test,
                                     const PreferenceValues& entries) {
-    if (!test->CreateRoot(syncable::PREFERENCES))
+    if (!test->CreateRoot(syncer::PREFERENCES))
       return;
 
     for (PreferenceValues::const_iterator i = entries.begin();
          i != entries.end(); ++i) {
       if (test->SetSyncedValue(i->first, *i->second) == syncer::kInvalidId)
         return;
     }
     success_ = true;
   }
 
   base::Closure callback_;
   bool success_;
 };
 
 TEST_F(ProfileSyncServicePreferenceTest, CreatePrefSyncData) {
   prefs_->SetString(prefs::kHomePage, example_url0_);
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  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(),
       *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()));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, ModelAssociationDoNotSyncDefaults) {
   const PrefService::Preference* pref =
       prefs_->FindPreference(prefs::kHomePage);
   EXPECT_TRUE(pref->IsDefaultValue());
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
   EXPECT_TRUE(IsSynced(prefs::kHomePage));
   EXPECT_TRUE(pref->IsDefaultValue());
   EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL);
   EXPECT_TRUE(GetSyncedValue(not_synced_preference_name_) == NULL);
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, ModelAssociationEmptyCloud) {
   prefs_->SetString(prefs::kHomePage, example_url0_);
   {
     ListPrefUpdate update(prefs_, prefs::kURLsToRestoreOnStartup);
     ListValue* url_list = update.Get();
     url_list->Append(Value::CreateStringValue(example_url0_));
     url_list->Append(Value::CreateStringValue(example_url1_));
   }
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<const Value> value(GetSyncedValue(prefs::kHomePage));
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(GetPreferenceValue(prefs::kHomePage).Equals(value.get()));
   value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartup));
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(
       GetPreferenceValue(prefs::kURLsToRestoreOnStartup).Equals(value.get()));
@@ skipping 52 matching lines @@
 TEST_F(ProfileSyncServicePreferenceTest, FailModelAssociation) {
   ASSERT_TRUE(StartSyncService(base::Closure(), true));
   EXPECT_TRUE(service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedPreferenceWithDefaultValue) {
   const PrefService::Preference* pref =
       prefs_->FindPreference(prefs::kHomePage);
   EXPECT_TRUE(pref->IsDefaultValue());
 
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url0_));
   profile_->GetPrefs()->Set(prefs::kHomePage, *expected);
 
   scoped_ptr<const Value> actual(GetSyncedValue(prefs::kHomePage));
   ASSERT_TRUE(actual.get());
   EXPECT_TRUE(expected->Equals(actual.get()));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedPreferenceWithValue) {
   profile_->GetPrefs()->SetString(prefs::kHomePage, example_url0_);
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url1_));
   profile_->GetPrefs()->Set(prefs::kHomePage, *expected);
 
   scoped_ptr<const Value> actual(GetSyncedValue(prefs::kHomePage));
   ASSERT_TRUE(actual.get());
   EXPECT_TRUE(expected->Equals(actual.get()));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionUpdate) {
   profile_->GetPrefs()->SetString(prefs::kHomePage, example_url0_);
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url1_));
   int64 node_id = SetSyncedValue(prefs::kHomePage, *expected);
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   const Value& actual = GetPreferenceValue(prefs::kHomePage);
   EXPECT_TRUE(expected->Equals(&actual));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionAdd) {
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url0_));
   int64 node_id = SetSyncedValue(prefs::kHomePage, *expected);
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_ADD));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   const Value& actual = GetPreferenceValue(prefs::kHomePage);
   EXPECT_TRUE(expected->Equals(&actual));
   EXPECT_EQ(1U,
       pref_sync_service_->registered_preferences().count(prefs::kHomePage));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeUnknownPreference) {
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url0_));
   int64 node_id = SetSyncedValue("unknown preference", *expected);
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   // Nothing interesting happens on the client when it gets an update
   // of an unknown preference.  We just should not crash.
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, ManagedPreferences) {
   // Make the homepage preference managed.
   scoped_ptr<Value> managed_value(
       Value::CreateStringValue("http://example.com"));
   prefs_->SetManagedPref(prefs::kHomePage, managed_value->DeepCopy());
 
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   // Changing the homepage preference should not sync anything.
   scoped_ptr<Value> user_value(
       Value::CreateStringValue("http://chromium..com"));
   prefs_->SetUserPref(prefs::kHomePage, user_value->DeepCopy());
   EXPECT_EQ(NULL, GetSyncedValue(prefs::kHomePage));
 
   // An incoming sync transaction should change the user value, not the managed
   // value.
   scoped_ptr<Value> sync_value(
       Value::CreateStringValue("http://crbug.com"));
   int64 node_id = SetSyncedValue(prefs::kHomePage, *sync_value);
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   EXPECT_TRUE(managed_value->Equals(prefs_->GetManagedPref(prefs::kHomePage)));
   EXPECT_TRUE(sync_value->Equals(prefs_->GetUserPref(prefs::kHomePage)));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, DynamicManagedPreferences) {
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  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));
   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)));
 
   // Switch kHomePage back to unmanaged.
   profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
 
   // The original value should be picked up.
   EXPECT_TRUE(initial_value->Equals(&GetPreferenceValue(prefs::kHomePage)));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest,
        DynamicManagedPreferencesWithSyncChange) {
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  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));
   EXPECT_TRUE(initial_value->Equals(actual.get()));
 
   // Switch kHomePage to managed and set a different value.
@@ skipping 23 matching lines @@
   profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
 
   // Sync value should be picked up.
   EXPECT_TRUE(sync_value->Equals(&GetPreferenceValue(prefs::kHomePage)));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, DynamicManagedDefaultPreferences) {
   const PrefService::Preference* pref =
       prefs_->FindPreference(prefs::kHomePage);
   EXPECT_TRUE(pref->IsDefaultValue());
-  CreateRootHelper create_root(this, syncable::PREFERENCES);
+  CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
   EXPECT_TRUE(IsSynced(prefs::kHomePage));
   EXPECT_TRUE(pref->IsDefaultValue());
   EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL);
   // 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)));
   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);
 }