[Sync] Rename csync namespace to syncer

sync/internal_api/syncapi_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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 49 matching lines @@
 #include "sync/test/fake_encryptor.h"
 #include "sync/test/fake_extensions_activity_monitor.h"
 #include "sync/util/cryptographer.h"
 #include "sync/util/extensions_activity_monitor.h"
 #include "sync/util/test_unrecoverable_error_handler.h"
 #include "sync/util/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ExpectDictStringValue;
-using csync::Cryptographer;
-using csync::FakeEncryptor;
-using csync::FakeExtensionsActivityMonitor;
-using csync::HasArgsAsList;
-using csync::HasDetailsAsDictionary;
-using csync::KeyParams;
-using csync::kNigoriTag;
-using csync::JsArgList;
-using csync::JsBackend;
-using csync::JsEventHandler;
-using csync::JsReplyHandler;
-using csync::MockJsEventHandler;
-using csync::MockJsReplyHandler;
-using csync::ModelSafeRoutingInfo;
-using csync::ModelSafeWorker;
-using csync::sessions::SyncSessionSnapshot;
-using csync::TestUnrecoverableErrorHandler;
-using csync::WeakHandle;
+using syncer::Cryptographer;
+using syncer::FakeEncryptor;
+using syncer::FakeExtensionsActivityMonitor;
+using syncer::HasArgsAsList;
+using syncer::HasDetailsAsDictionary;
+using syncer::KeyParams;
+using syncer::kNigoriTag;
+using syncer::JsArgList;
+using syncer::JsBackend;
+using syncer::JsEventHandler;
+using syncer::JsReplyHandler;
+using syncer::MockJsEventHandler;
+using syncer::MockJsReplyHandler;
+using syncer::ModelSafeRoutingInfo;
+using syncer::ModelSafeWorker;
+using syncer::sessions::SyncSessionSnapshot;
+using syncer::TestUnrecoverableErrorHandler;
+using syncer::WeakHandle;
 using syncable::IS_DEL;
 using syncable::IS_UNSYNCED;
 using syncable::kEncryptedString;
 using syncable::ModelTypeSet;
 using syncable::ModelType;
 using syncable::NON_UNIQUE_NAME;
 using syncable::SPECIFICS;
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::InSequence;
 using testing::Invoke;
 using testing::SaveArg;
 using testing::StrictMock;
 
-namespace csync {
+namespace syncer {
 
 namespace {
 
 const char kTestChromeVersion[] = "test chrome version";
 
 void DoNothing() {}
 
 void ExpectInt64Value(int64 expected_value,
                       const DictionaryValue& value, const std::string& key) {
   std::string int64_str;
   EXPECT_TRUE(value.GetString(key, &int64_str));
   int64 val = 0;
   EXPECT_TRUE(base::StringToInt64(int64_str, &val));
   EXPECT_EQ(expected_value, val);
 }
 
 void ExpectTimeValue(const base::Time& expected_value,
                      const DictionaryValue& value, const std::string& key) {
   std::string time_str;
   EXPECT_TRUE(value.GetString(key, &time_str));
-  EXPECT_EQ(csync::GetTimeDebugString(expected_value), time_str);
+  EXPECT_EQ(syncer::GetTimeDebugString(expected_value), time_str);
 }
 
 // Makes a non-folder child of the root node.  Returns the id of the
 // newly-created node.
 int64 MakeNode(UserShare* share,
                ModelType model_type,
                const std::string& client_tag) {
   WriteTransaction trans(FROM_HERE, share);
   ReadNode root_node(&trans);
   root_node.InitByRootLookup();
   WriteNode node(&trans);
-  csync::WriteNode::InitUniqueByCreationResult result =
+  syncer::WriteNode::InitUniqueByCreationResult result =
       node.InitUniqueByCreation(model_type, root_node, client_tag);
-  EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+  EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
   node.SetIsFolder(false);
   return node.GetId();
 }
 
 // Makes a non-folder child of a non-root node. Returns the id of the
 // newly-created node.
 int64 MakeNodeWithParent(UserShare* share,
                          ModelType model_type,
                          const std::string& client_tag,
                          int64 parent_id) {
   WriteTransaction trans(FROM_HERE, share);
   ReadNode parent_node(&trans);
   EXPECT_EQ(BaseNode::INIT_OK, parent_node.InitByIdLookup(parent_id));
   WriteNode node(&trans);
-  csync::WriteNode::InitUniqueByCreationResult result =
+  syncer::WriteNode::InitUniqueByCreationResult result =
       node.InitUniqueByCreation(model_type, parent_node, client_tag);
-  EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+  EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
   node.SetIsFolder(false);
   return node.GetId();
 }
 
 // Makes a folder child of a non-root node. Returns the id of the
 // newly-created node.
 int64 MakeFolderWithParent(UserShare* share,
                            ModelType model_type,
                            int64 parent_id,
                            BaseNode* predecessor) {
@@ skipping 72 matching lines @@
   virtual void SetUp() {
     test_user_share_.SetUp();
   }
 
   virtual void TearDown() {
     test_user_share_.TearDown();
   }
 
  protected:
   MessageLoop message_loop_;
-  csync::TestUserShare test_user_share_;
+  syncer::TestUserShare test_user_share_;
 };
 
 TEST_F(SyncApiTest, SanityCheckTest) {
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     EXPECT_TRUE(trans.GetWrappedTrans() != NULL);
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     EXPECT_TRUE(trans.GetWrappedTrans() != NULL);
@@ skipping 115 matching lines @@
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     // we'll use this spare folder later
     WriteNode folder_node(&trans);
     EXPECT_TRUE(folder_node.InitByCreation(syncable::BOOKMARKS,
         root_node, NULL));
     folder_id = folder_node.GetId();
 
     WriteNode wnode(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode::InitUniqueByCreationResult result =
         wnode.InitUniqueByCreation(syncable::BOOKMARKS, root_node, "testtag");
-    EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     wnode.SetIsFolder(false);
     wnode.SetTitle(UTF8ToWide(test_title));
 
     node_id = wnode.GetId();
   }
 
   // Ensure we can delete something with a tag.
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     WriteNode wnode(&trans);
@@ skipping 19 matching lines @@
     EXPECT_EQ(node.GetTitle(), test_title);
   }
 
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode folder_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, folder_node.InitByIdLookup(folder_id));
 
     WriteNode wnode(&trans);
     // This will undelete the tag.
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode::InitUniqueByCreationResult result =
         wnode.InitUniqueByCreation(syncable::BOOKMARKS, folder_node, "testtag");
-    EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     EXPECT_EQ(wnode.GetIsFolder(), false);
     EXPECT_EQ(wnode.GetParentId(), folder_node.GetId());
     EXPECT_EQ(wnode.GetId(), node_id);
     EXPECT_NE(wnode.GetTitle(), test_title);  // Title should be cleared
     wnode.SetTitle(UTF8ToWide(test_title));
   }
 
   // Now look up should work.
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
@@ skipping 11 matching lines @@
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     trans.GetCryptographer()->AddKey(params);
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode::InitUniqueByCreationResult result =
         password_node.InitUniqueByCreation(syncable::PASSWORDS,
                                            root_node, "foo");
-    EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     password_node.SetPasswordSpecifics(data);
   }
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     ReadNode password_node(&trans);
@@ skipping 12 matching lines @@
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     trans.GetCryptographer()->AddKey(params);
     trans.GetCryptographer()->set_encrypt_everything();
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode bookmark_node(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode::InitUniqueByCreationResult result =
         bookmark_node.InitUniqueByCreation(syncable::BOOKMARKS,
                                            root_node, "foo");
-    EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     bookmark_node.SetTitle(UTF8ToWide("foo"));
 
     WriteNode pref_node(&trans);
     result =
         pref_node.InitUniqueByCreation(syncable::PREFERENCES, root_node, "bar");
-    EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     pref_node.SetTitle(UTF8ToWide("bar"));
   }
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     ReadNode bookmark_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               bookmark_node.InitByClientTagLookup(syncable::BOOKMARKS,
@@ skipping 117 matching lines @@
     ADD_FAILURE();
   }
 }
 
 TEST_F(SyncApiTest, EmptyTags) {
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   ReadNode root_node(&trans);
   root_node.InitByRootLookup();
   WriteNode node(&trans);
   std::string empty_tag;
-  csync::WriteNode::InitUniqueByCreationResult result =
+  syncer::WriteNode::InitUniqueByCreationResult result =
       node.InitUniqueByCreation(syncable::TYPED_URLS, root_node, empty_tag);
-  EXPECT_NE(csync::WriteNode::INIT_SUCCESS, result);
+  EXPECT_NE(syncer::WriteNode::INIT_SUCCESS, result);
   EXPECT_EQ(BaseNode::INIT_FAILED_PRECONDITION,
             node.InitByTagLookup(empty_tag));
 }
 
 namespace {
 
 class TestHttpPostProviderInterface : public HttpPostProviderInterface {
  public:
   virtual ~TestHttpPostProviderInterface() {}
 
@@ skipping 31 matching lines @@
 };
 
 class SyncManagerObserverMock : public SyncManager::Observer {
  public:
   MOCK_METHOD1(OnSyncCycleCompleted,
                void(const SyncSessionSnapshot&));  // NOLINT
   MOCK_METHOD2(OnInitializationComplete,
                void(const WeakHandle<JsBackend>&, bool));  // NOLINT
   MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus));  // NOLINT
   MOCK_METHOD2(OnPassphraseRequired,
-               void(csync::PassphraseRequiredReason,
+               void(syncer::PassphraseRequiredReason,
                     const sync_pb::EncryptedData&));  // NOLINT
   MOCK_METHOD0(OnPassphraseAccepted, void());  // NOLINT
   MOCK_METHOD1(OnBootstrapTokenUpdated, void(const std::string&));  // NOLINT
   MOCK_METHOD0(OnStopSyncingPermanently, void());  // NOLINT
   MOCK_METHOD1(OnUpdatedToken, void(const std::string&));  // NOLINT
   MOCK_METHOD2(OnEncryptedTypesChanged,
                void(ModelTypeSet, bool));  // NOLINT
   MOCK_METHOD0(OnEncryptionComplete, void());  // NOLINT
   MOCK_METHOD1(OnActionableError,
-               void(const csync::SyncProtocolError&));  // NOLINT
+               void(const syncer::SyncProtocolError&));  // NOLINT
 };
 
-class SyncNotifierMock : public csync::SyncNotifier {
+class SyncNotifierMock : public syncer::SyncNotifier {
  public:
-  MOCK_METHOD1(AddObserver, void(csync::SyncNotifierObserver*));
-  MOCK_METHOD1(RemoveObserver, void(csync::SyncNotifierObserver*));
+  MOCK_METHOD1(AddObserver, void(syncer::SyncNotifierObserver*));
+  MOCK_METHOD1(RemoveObserver, void(syncer::SyncNotifierObserver*));
   MOCK_METHOD1(SetUniqueId, void(const std::string&));
   MOCK_METHOD1(SetStateDeprecated, void(const std::string&));
   MOCK_METHOD2(UpdateCredentials,
                void(const std::string&, const std::string&));
   MOCK_METHOD1(UpdateEnabledTypes,
                void(syncable::ModelTypeSet));
   MOCK_METHOD1(SendNotification, void(syncable::ModelTypeSet));
 };
 
 }  // namespace
@@ skipping 56 matching lines @@
 
     // Takes ownership of |sync_notifier_mock_|.
     sync_manager_.Init(temp_dir_.path(),
                        WeakHandle<JsEventHandler>(),
                        "bogus", 0, false,
                        base::MessageLoopProxy::current(),
                        new TestHttpPostProviderFactory(), routing_info, workers,
                        &extensions_activity_monitor_, this,
                        credentials,
                        sync_notifier_mock_, "",
-                       csync::SyncManager::TEST_IN_MEMORY,
+                       syncer::SyncManager::TEST_IN_MEMORY,
                        &encryptor_,
                        &handler_,
                        NULL);
 
     EXPECT_TRUE(sync_notifier_observer_);
     EXPECT_TRUE(js_backend_.IsInitialized());
 
     EXPECT_EQ(0, update_enabled_types_call_count_);
 
     for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
          i != routing_info.end(); ++i) {
       type_roots_[i->first] = MakeServerNodeForType(
           sync_manager_.GetUserShare(), i->first);
     }
     PumpLoop();
   }
 
   void TearDown() {
     sync_manager_.RemoveObserver(&observer_);
     sync_manager_.ShutdownOnSyncThread();
     sync_notifier_mock_ = NULL;
     EXPECT_FALSE(sync_notifier_observer_);
     PumpLoop();
   }
 
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
-    (*out)[syncable::NIGORI] = csync::GROUP_PASSIVE;
-    (*out)[syncable::BOOKMARKS] = csync::GROUP_PASSIVE;
-    (*out)[syncable::THEMES] = csync::GROUP_PASSIVE;
-    (*out)[syncable::SESSIONS] = csync::GROUP_PASSIVE;
-    (*out)[syncable::PASSWORDS] = csync::GROUP_PASSIVE;
-    (*out)[syncable::PREFERENCES] = csync::GROUP_PASSIVE;
+    (*out)[syncable::NIGORI] = syncer::GROUP_PASSIVE;
+    (*out)[syncable::BOOKMARKS] = syncer::GROUP_PASSIVE;
+    (*out)[syncable::THEMES] = syncer::GROUP_PASSIVE;
+    (*out)[syncable::SESSIONS] = syncer::GROUP_PASSIVE;
+    (*out)[syncable::PASSWORDS] = syncer::GROUP_PASSIVE;
+    (*out)[syncable::PREFERENCES] = syncer::GROUP_PASSIVE;
   }
 
   virtual void OnChangesApplied(
       syncable::ModelType model_type,
       const BaseTransaction* trans,
       const ImmutableChangeRecordList& changes) OVERRIDE {}
 
   virtual void OnChangesComplete(syncable::ModelType model_type) OVERRIDE {}
 
   // Helper methods.
@@ skipping 31 matching lines @@
     return cryptographer->is_ready();
   }
 
   int64 GetIdForDataType(ModelType type) {
     if (type_roots_.count(type) == 0)
       return 0;
     return type_roots_[type];
   }
 
   void SyncNotifierAddObserver(
-      csync::SyncNotifierObserver* sync_notifier_observer) {
+      syncer::SyncNotifierObserver* sync_notifier_observer) {
     EXPECT_EQ(NULL, sync_notifier_observer_);
     sync_notifier_observer_ = sync_notifier_observer;
   }
 
   void SyncNotifierRemoveObserver(
-      csync::SyncNotifierObserver* sync_notifier_observer) {
+      syncer::SyncNotifierObserver* sync_notifier_observer) {
     EXPECT_EQ(sync_notifier_observer_, sync_notifier_observer);
     sync_notifier_observer_ = NULL;
   }
 
   void SyncNotifierUpdateEnabledTypes(syncable::ModelTypeSet types) {
     ModelSafeRoutingInfo routes;
     GetModelSafeRoutingInfo(&routes);
     const syncable::ModelTypeSet expected_types =
         GetRoutingInfoTypes(routes);
     EXPECT_TRUE(types.Equals(expected_types));
@@ skipping 44 matching lines @@
   std::map<ModelType, int64> type_roots_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
   StrictMock<SyncNotifierMock>* sync_notifier_mock_;
 
  protected:
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   SyncManager sync_manager_;
   WeakHandle<JsBackend> js_backend_;
   StrictMock<SyncManagerObserverMock> observer_;
-  csync::SyncNotifierObserver* sync_notifier_observer_;
+  syncer::SyncNotifierObserver* sync_notifier_observer_;
   int update_enabled_types_call_count_;
 };
 
 TEST_F(SyncManagerTest, UpdateEnabledTypes) {
   EXPECT_EQ(0, update_enabled_types_call_count_);
 
   ModelSafeRoutingInfo routes;
   GetModelSafeRoutingInfo(&routes);
   const syncable::ModelTypeSet enabled_types =
         GetRoutingInfoTypes(routes);
@@ skipping 303 matching lines @@
 
   EXPECT_CALL(event_handler,
               HandleJsEvent("onNotificationStateChange",
                             HasDetailsAsDictionary(true_details)));
   EXPECT_CALL(event_handler,
               HandleJsEvent("onNotificationStateChange",
                             HasDetailsAsDictionary(false_details)));
 
   sync_manager_.SimulateEnableNotificationsForTest();
   sync_manager_.SimulateDisableNotificationsForTest(
-      csync::TRANSIENT_NOTIFICATION_ERROR);
+      syncer::TRANSIENT_NOTIFICATION_ERROR);
 
   SetJsEventHandler(event_handler.AsWeakHandle());
   sync_manager_.SimulateEnableNotificationsForTest();
   sync_manager_.SimulateDisableNotificationsForTest(
-      csync::TRANSIENT_NOTIFICATION_ERROR);
+      syncer::TRANSIENT_NOTIFICATION_ERROR);
   SetJsEventHandler(WeakHandle<JsEventHandler>());
 
   sync_manager_.SimulateEnableNotificationsForTest();
   sync_manager_.SimulateDisableNotificationsForTest(
-      csync::TRANSIENT_NOTIFICATION_ERROR);
+      syncer::TRANSIENT_NOTIFICATION_ERROR);
 
   // Should trigger the replies.
   PumpLoop();
 }
 
 TEST_F(SyncManagerTest, OnIncomingNotification) {
   StrictMock<MockJsEventHandler> event_handler;
 
   const syncable::ModelTypeSet empty_model_types;
   const syncable::ModelTypeSet model_types(
@@ skipping 280 matching lines @@
     // Store the default (soon to be old) key.
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     verifier.Bootstrap(bootstrap_token);
 
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode::InitUniqueByCreationResult result =
         password_node.InitUniqueByCreation(syncable::PASSWORDS,
                                            root_node, "foo");
-    EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     password_node.SetPasswordSpecifics(data);
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
@@ skipping 210 matching lines @@
 TEST_F(SyncManagerTest, SetPassphraseWithEmptyPasswordNode) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   int64 node_id = 0;
   std::string tag = "foo";
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
-    csync::WriteNode::InitUniqueByCreationResult result =
+    syncer::WriteNode::InitUniqueByCreationResult result =
         password_node.InitUniqueByCreation(syncable::PASSWORDS, root_node, tag);
-    EXPECT_EQ(csync::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     node_id = password_node.GetId();
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
               password_node.InitByClientTagLookup(syncable::PASSWORDS,
                                                   tag));
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
               password_node.InitByIdLookup(node_id));
   }
 }
 
 TEST_F(SyncManagerTest, NudgeDelayTest) {
   EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncable::BOOKMARKS),
       base::TimeDelta::FromMilliseconds(
           SyncManager::kDefaultNudgeDelayMilliseconds));
 
   EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncable::AUTOFILL),
       base::TimeDelta::FromSeconds(
-          csync::kDefaultShortPollIntervalSeconds));
+          syncer::kDefaultShortPollIntervalSeconds));
 
   EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncable::PREFERENCES),
       base::TimeDelta::FromMilliseconds(
           SyncManager::kPreferencesNudgeDelayMilliseconds));
 }
 
 // Friended by WriteNode, so can't be in an anonymouse namespace.
 TEST_F(SyncManagerTest, EncryptBookmarksWithLegacyData) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   std::string title;
@@ skipping 598 matching lines @@
 // the data.
 TEST_F(SyncManagerTest, SetPreviouslyEncryptedSpecifics) {
   std::string client_tag = "tag";
   std::string url = "url";
   std::string url2 = "new_url";
   std::string title = "title";
   sync_pb::EntitySpecifics entity_specifics;
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
-    csync::Cryptographer* crypto = trans.GetCryptographer();
+    syncer::Cryptographer* crypto = trans.GetCryptographer();
     sync_pb::EntitySpecifics bm_specifics;
     bm_specifics.mutable_bookmark()->set_title("title");
     bm_specifics.mutable_bookmark()->set_url("url");
     sync_pb::EncryptedData encrypted;
     crypto->Encrypt(bm_specifics, &encrypted);
     entity_specifics.mutable_encrypted()->CopyFrom(encrypted);
     syncable::AddDefaultFieldValue(syncable::BOOKMARKS, &entity_specifics);
   }
   MakeServerNode(sync_manager_.GetUserShare(), syncable::BOOKMARKS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
@@ skipping 27 matching lines @@
               node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(GURL(url2), node.GetURL());
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
   }
 }
 
-}  // namespace csync
+}  // namespace syncer