[Sync] Rename csync namespace to syncer

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 25 matching lines @@
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONReader;
 using browser_sync::GenericChangeProcessor;
 using browser_sync::SharedChangeProcessor;
 using browser_sync::UIDataTypeController;
-using csync::ChangeRecord;
+using syncer::ChangeRecord;
 using testing::_;
 using testing::Invoke;
 using testing::Return;
 
 typedef std::map<const std::string, const Value*> PreferenceValues;
 
 ACTION_P(CreateAndSaveChangeProcessor, change_processor) {
-  csync::UserShare* user_share = arg0->GetUserShare();
+  syncer::UserShare* user_share = arg0->GetUserShare();
   *change_processor = new GenericChangeProcessor(arg1, arg2, user_share);
   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) {
-    csync::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
-    csync::ReadNode root(&trans);
+    syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+    syncer::ReadNode root(&trans);
     if (root.InitByTagLookup(syncable::ModelTypeToRootTag(
-            syncable::PREFERENCES)) != csync::BaseNode::INIT_OK) {
-      return csync::kInvalidId;
+            syncable::PREFERENCES)) != syncer::BaseNode::INIT_OK) {
+      return syncer::kInvalidId;
     }
 
-    csync::WriteNode tag_node(&trans);
-    csync::WriteNode node(&trans);
+    syncer::WriteNode tag_node(&trans);
+    syncer::WriteNode node(&trans);
 
     if (tag_node.InitByClientTagLookup(syncable::PREFERENCES, name) ==
-            csync::BaseNode::INIT_OK) {
+            syncer::BaseNode::INIT_OK) {
       return WriteSyncedValue(name, value, &tag_node);
     }
 
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode::InitUniqueByCreationResult result =
         node.InitUniqueByCreation(syncable::PREFERENCES, root, name);
-    if (result == csync::WriteNode::INIT_SUCCESS)
+    if (result == syncer::WriteNode::INIT_SUCCESS)
       return WriteSyncedValue(name, value, &node);
 
-    return csync::kInvalidId;
+    return syncer::kInvalidId;
   }
 
  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") {}
@@ skipping 58 matching lines @@
   }
 
   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) {
-    csync::ReadTransaction trans(FROM_HERE, service_->GetUserShare());
-    csync::ReadNode node(&trans);
+    syncer::ReadTransaction trans(FROM_HERE, service_->GetUserShare());
+    syncer::ReadNode node(&trans);
 
     if (node.InitByClientTagLookup(syncable::PREFERENCES, name) !=
-            csync::BaseNode::INIT_OK) {
+            syncer::BaseNode::INIT_OK) {
       return NULL;
     }
 
     const sync_pb::PreferenceSpecifics& specifics(
         node.GetEntitySpecifics().preference());
 
     return base::JSONReader::Read(specifics.value());
   }
 
   int64 WriteSyncedValue(const std::string& name,
                          const Value& value,
-                         csync::WriteNode* node) {
-    csync::SyncData sync_data;
+                         syncer::WriteNode* node) {
+    syncer::SyncData sync_data;
     if (!PrefModelAssociator::CreatePrefSyncData(name,
                                                  value,
                                                  &sync_data)) {
-      return csync::kInvalidId;
+      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) {
@@ skipping 33 matching lines @@
   bool success() { return success_; }
 
  private:
   void AddPreferenceEntriesCallback(ProfileSyncServicePreferenceTest* test,
                                     const PreferenceValues& entries) {
     if (!test->CreateRoot(syncable::PREFERENCES))
       return;
 
     for (PreferenceValues::const_iterator i = entries.begin();
          i != entries.end(); ++i) {
-      if (test->SetSyncedValue(i->first, *i->second) == csync::kInvalidId)
+      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);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   const PrefService::Preference* pref =
       prefs_->FindPreference(prefs::kHomePage);
-  csync::SyncData sync_data;
+  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()));
 }
@@ skipping 119 matching lines @@
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionUpdate) {
   profile_->GetPrefs()->SetString(prefs::kHomePage, example_url0_);
   CreateRootHelper create_root(this, syncable::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, csync::kInvalidId);
+  ASSERT_NE(node_id, syncer::kInvalidId);
   {
-    csync::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+    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);
   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, csync::kInvalidId);
+  ASSERT_NE(node_id, syncer::kInvalidId);
   {
-    csync::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+    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);
   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, csync::kInvalidId);
+  ASSERT_NE(node_id, syncer::kInvalidId);
   {
-    csync::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+    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.
 }
@@ skipping 12 matching lines @@
   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, csync::kInvalidId);
+  ASSERT_NE(node_id, syncer::kInvalidId);
   {
-    csync::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+    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)));
 }
@@ skipping 40 matching lines @@
   // 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());
 
   // Change the sync value.
   scoped_ptr<Value> sync_value(
       Value::CreateStringValue("http://example.com/sync"));
   int64 node_id = SetSyncedValue(prefs::kHomePage, *sync_value);
-  ASSERT_NE(node_id, csync::kInvalidId);
+  ASSERT_NE(node_id, syncer::kInvalidId);
   {
-    csync::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+    syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_ADD));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   // The pref value should still be the one dictated by policy.
   EXPECT_TRUE(managed_value->Equals(&GetPreferenceValue(prefs::kHomePage)));
 
@@ skipping 24 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);
 }