[Sync] Rename csync namespace to syncer

chrome/browser/extensions/app_notification_manager_sync_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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/extensions/app_notification.h"
 #include "chrome/browser/extensions/app_notification_manager.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/protocol/app_notification_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using ::testing::_;
 using ::testing::Return;
 
 namespace {
 
-// Extract notification guid from csync::SyncData.
-std::string GetGuid(const csync::SyncData& sync_data) {
+// Extract notification guid from syncer::SyncData.
+std::string GetGuid(const syncer::SyncData& sync_data) {
   return sync_data.GetSpecifics().app_notification().guid();
 }
 
 // Dummy SyncChangeProcessor used to help review what SyncChanges are pushed
 // back up to Sync.
-class TestChangeProcessor : public csync::SyncChangeProcessor {
+class TestChangeProcessor : public syncer::SyncChangeProcessor {
  public:
   TestChangeProcessor() { }
   virtual ~TestChangeProcessor() { }
 
   // Store a copy of all the changes passed in so we can examine them later.
-  virtual csync::SyncError ProcessSyncChanges(
+  virtual syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
-      const csync::SyncChangeList& change_list) {
+      const syncer::SyncChangeList& change_list) {
     // change_map_.erase(change_map_.begin(), change_map_.end());
-    for (csync::SyncChangeList::const_iterator iter = change_list.begin();
+    for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
         iter != change_list.end(); ++iter) {
       change_map_[GetGuid(iter->sync_data())] = *iter;
     }
 
-    return csync::SyncError();
+    return syncer::SyncError();
   }
 
   bool ContainsGuid(const std::string& guid) {
     return change_map_.find(guid) != change_map_.end();
   }
 
-  csync::SyncChange GetChangeByGuid(const std::string& guid) {
+  syncer::SyncChange GetChangeByGuid(const std::string& guid) {
     DCHECK(ContainsGuid(guid));
     return change_map_[guid];
   }
 
   size_t change_list_size() { return change_map_.size(); }
 
  private:
   // Track the changes received in ProcessSyncChanges.
-  std::map<std::string, csync::SyncChange> change_map_;
+  std::map<std::string, syncer::SyncChange> change_map_;
 
   DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor);
 };
 
-class SyncChangeProcessorDelegate : public csync::SyncChangeProcessor {
+class SyncChangeProcessorDelegate : public syncer::SyncChangeProcessor {
  public:
-  explicit SyncChangeProcessorDelegate(csync::SyncChangeProcessor* recipient)
+  explicit SyncChangeProcessorDelegate(syncer::SyncChangeProcessor* recipient)
       : recipient_(recipient) {
     DCHECK(recipient_);
   }
   virtual ~SyncChangeProcessorDelegate() {}
 
-  // csync::SyncChangeProcessor implementation.
-  virtual csync::SyncError ProcessSyncChanges(
+  // syncer::SyncChangeProcessor implementation.
+  virtual syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
-      const csync::SyncChangeList& change_list) OVERRIDE {
+      const syncer::SyncChangeList& change_list) OVERRIDE {
     return recipient_->ProcessSyncChanges(from_here, change_list);
   }
 
  private:
   // The recipient of all sync changes.
-  csync::SyncChangeProcessor* recipient_;
+  syncer::SyncChangeProcessor* recipient_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncChangeProcessorDelegate);
 };
 
 }  // namespace
 
 class AppNotificationManagerSyncTest : public testing::Test {
  public:
   AppNotificationManagerSyncTest()
       : ui_thread_(BrowserThread::UI, &ui_loop_),
@@ skipping 32 matching lines @@
   static void WaitForFileThread() {
     BrowserThread::PostTask(BrowserThread::FILE,
                             FROM_HERE,
                             base::Bind(&PostQuitToUIThread));
     MessageLoop::current()->Run();
   }
 
   AppNotificationManager* model() { return model_.get(); }
   TestChangeProcessor* processor() { return sync_processor_.get(); }
 
-  scoped_ptr<csync::SyncChangeProcessor> PassProcessor() {
-    return sync_processor_delegate_.PassAs<csync::SyncChangeProcessor>();
+  scoped_ptr<syncer::SyncChangeProcessor> PassProcessor() {
+    return sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>();
   }
 
   // Creates a notification whose properties are set from the given integer.
   static AppNotification* CreateNotification(int suffix) {
     return CreateNotification(false, suffix);
   }
   static AppNotification* CreateNotification(bool is_local, int suffix) {
     std::string s = base::IntToString(suffix);
     return CreateNotification(
         is_local, suffix, "guid" + s, "ext" + s, "text" + s, "body" + s,
@@ skipping 31 matching lines @@
     AppNotification* notif = new AppNotification(
         is_local, base::Time::FromInternalValue(time),
         guid, extension_id, title, body);
     if (!link_url.empty())
       notif->set_link_url(GURL(link_url));
     if (!link_text.empty())
       notif->set_link_text(link_text);
     return notif;
   }
 
-  static csync::SyncData CreateSyncData(int suffix) {
+  static syncer::SyncData CreateSyncData(int suffix) {
     scoped_ptr<AppNotification> notif(CreateNotification(suffix));
     return AppNotificationManager::CreateSyncDataFromNotification(*notif);
   }
-  static csync::SyncData CreateSyncData(
+  static syncer::SyncData CreateSyncData(
       int suffix, const std::string& extension_id) {
     scoped_ptr<AppNotification> notif(
         CreateNotification(false, suffix, extension_id));
     return AppNotificationManager::CreateSyncDataFromNotification(*notif);
   }
 
-  // Helper to create csync::SyncChange. Takes ownership of |notif|.
-  static csync::SyncChange CreateSyncChange(
-      csync::SyncChange::SyncChangeType type,
+  // Helper to create syncer::SyncChange. Takes ownership of |notif|.
+  static syncer::SyncChange CreateSyncChange(
+      syncer::SyncChange::SyncChangeType type,
       AppNotification* notif) {
     // Take control of notif to clean it up after we create data out of it.
     scoped_ptr<AppNotification> scoped_notif(notif);
-    return csync::SyncChange(
+    return syncer::SyncChange(
         type, AppNotificationManager::CreateSyncDataFromNotification(*notif));
   }
 
-  void AssertSyncChange(const csync::SyncChange& change,
-                        csync::SyncChange::SyncChangeType type,
+  void AssertSyncChange(const syncer::SyncChange& change,
+                        syncer::SyncChange::SyncChangeType type,
                         const AppNotification& notif) {
     ASSERT_EQ(type, change.change_type());
     scoped_ptr<AppNotification> notif2(
         AppNotificationManager::CreateNotificationFromSyncData(
             change.sync_data()));
     ASSERT_TRUE(notif.Equals(*notif2));
   }
 
  protected:
   MessageLoop ui_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   // We keep two TemplateURLServices to test syncing between them.
   ScopedTempDir temp_dir_;
   scoped_ptr<TestingProfile> profile_;
   scoped_refptr<AppNotificationManager> model_;
 
   scoped_ptr<TestChangeProcessor> sync_processor_;
   scoped_ptr<SyncChangeProcessorDelegate> sync_processor_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AppNotificationManagerSyncTest);
 };
 
-// Create an AppNotification, convert it to csync::SyncData and convert it back.
+// Create an AppNotification, convert it to SyncData and convert it back.
 TEST_F(AppNotificationManagerSyncTest, NotificationToSyncDataToNotification) {
   {  // Partial properties set.
     scoped_ptr<AppNotification> notif1(CreateNotificationNoLink(1));
-    csync::SyncData sync_data =
+    syncer::SyncData sync_data =
         AppNotificationManager::CreateSyncDataFromNotification(*notif1);
     scoped_ptr<AppNotification> notif2(
         AppNotificationManager::CreateNotificationFromSyncData(sync_data));
     EXPECT_TRUE(notif2.get());
     EXPECT_TRUE(notif1->Equals(*notif2));
   }
   {  // All properties set.
     scoped_ptr<AppNotification> notif1(CreateNotification(1));
-    csync::SyncData sync_data =
+    syncer::SyncData sync_data =
         AppNotificationManager::CreateSyncDataFromNotification(*notif1);
     scoped_ptr<AppNotification> notif2(
         AppNotificationManager::CreateNotificationFromSyncData(sync_data));
     EXPECT_TRUE(notif2.get());
     EXPECT_TRUE(notif1->Equals(*notif2));
   }
 }
 
 // GetAllSyncData returns all notifications since none are marked local only.
 TEST_F(AppNotificationManagerSyncTest, GetAllSyncDataNoLocal) {
   model()->Add(CreateNotificationNoLink(1));
   model()->Add(CreateNotification(2));
   model()->Add(CreateNotification(3));
-  csync::SyncDataList all_sync_data =
+  syncer::SyncDataList all_sync_data =
       model()->GetAllSyncData(syncable::APP_NOTIFICATIONS);
 
   EXPECT_EQ(3U, all_sync_data.size());
 
-  for (csync::SyncDataList::const_iterator iter = all_sync_data.begin();
+  for (syncer::SyncDataList::const_iterator iter = all_sync_data.begin();
       iter != all_sync_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
 
     const std::string& guid = notif1->guid();
     const std::string& ext_id = notif1->extension_id();
 
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     ASSERT_TRUE(notif1->Equals(*notif2));
   }
 }
 
 // GetAllSyncData should not return notifications marked as local only.
 TEST_F(AppNotificationManagerSyncTest, GetAllSyncDataSomeLocal) {
   model()->Add(CreateNotificationNoLink(1));
   model()->Add(CreateNotification(true, 2));
   model()->Add(CreateNotification(3));
   model()->Add(CreateNotification(true, 4));
   model()->Add(CreateNotification(5));
-  csync::SyncDataList all_sync_data =
+  syncer::SyncDataList all_sync_data =
       model()->GetAllSyncData(syncable::APP_NOTIFICATIONS);
 
   EXPECT_EQ(3U, all_sync_data.size());
 
-  for (csync::SyncDataList::const_iterator iter = all_sync_data.begin();
+  for (syncer::SyncDataList::const_iterator iter = all_sync_data.begin();
       iter != all_sync_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
     const std::string& guid = notif1->guid();
     const std::string& ext_id = notif1->extension_id();
 
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     ASSERT_TRUE(notif1->Equals(*notif2));
   }
 }
 
 // Model assocation: both models are empty.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocBothEmpty) {
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),  // Empty.
+      syncer::SyncDataList(),  // Empty.
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(0U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // Model assocation: empty sync model and non-empty local model.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocModelEmpty) {
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(1));
   initial_data.push_back(CreateSyncData(2));
   initial_data.push_back(CreateSyncData(3));
   initial_data.push_back(CreateSyncData(4));
 
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
   // Model should all of the initial sync data.
-  for (csync::SyncDataList::const_iterator iter = initial_data.begin();
+  for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
     const std::string& ext_id = notif1->extension_id();
     const std::string& guid = notif1->guid();
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     EXPECT_TRUE(notif2);
     EXPECT_TRUE(notif1->Equals(*notif2));
   }
 
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // Model has some notifications, some of them are local only. Sync has some
 // notifications. No items match up.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocBothNonEmptyNoOverlap) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(true, 2);
   model()->Add(n2);
   AppNotification* n3 = CreateNotification(3);
   model()->Add(n3);
 
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(4));
   initial_data.push_back(CreateSyncData(5));
   initial_data.push_back(CreateSyncData(6));
   initial_data.push_back(CreateSyncData(7));
 
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(6U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
-  for (csync::SyncDataList::const_iterator iter = initial_data.begin();
+  for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
     const std::string& ext_id = notif1->extension_id();
     const std::string& guid = notif1->guid();
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     EXPECT_TRUE(notif2);
     EXPECT_TRUE(notif1->Equals(*notif2));
   }
   EXPECT_TRUE(model()->GetNotification(n1->extension_id(), n1->guid()));
   EXPECT_TRUE(model()->GetNotification(n2->extension_id(), n2->guid()));
   EXPECT_TRUE(model()->GetNotification(n3->extension_id(), n3->guid()));
 
   EXPECT_EQ(2U, processor()->change_list_size());
   EXPECT_TRUE(processor()->ContainsGuid(n1->guid()));
-  EXPECT_EQ(csync::SyncChange::ACTION_ADD,
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             processor()->GetChangeByGuid(n1->guid()).change_type());
   EXPECT_FALSE(processor()->ContainsGuid(n2->guid()));
   EXPECT_TRUE(processor()->ContainsGuid(n3->guid()));
-  EXPECT_EQ(csync::SyncChange::ACTION_ADD,
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             processor()->GetChangeByGuid(n3->guid()).change_type());
 }
 
 // Model has some notifications, some of them are local only. Sync has some
 // notifications. Some items match up.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocBothNonEmptySomeOverlap) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(true, 2);
   model()->Add(n2);
   AppNotification* n3 = CreateNotification(3);
   model()->Add(n3);
   AppNotification* n4 = CreateNotification(4);
   model()->Add(n4);
 
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(5));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n1));
   initial_data.push_back(CreateSyncData(6));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n4));
   initial_data.push_back(CreateSyncData(7));
 
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(6U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
-  for (csync::SyncDataList::const_iterator iter = initial_data.begin();
+  for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     scoped_ptr<AppNotification> notif1(
         AppNotificationManager::CreateNotificationFromSyncData(*iter));
     const std::string& ext_id = notif1->extension_id();
     const std::string& guid = notif1->guid();
     const AppNotification* notif2 = model()->GetNotification(ext_id, guid);
     EXPECT_TRUE(notif2);
     EXPECT_TRUE(notif1->Equals(*notif2));
   }
   EXPECT_TRUE(model()->GetNotification(n1->extension_id(), n1->guid()));
   EXPECT_TRUE(model()->GetNotification(n2->extension_id(), n2->guid()));
   EXPECT_TRUE(model()->GetNotification(n3->extension_id(), n3->guid()));
   EXPECT_TRUE(model()->GetNotification(n4->extension_id(), n4->guid()));
 
   EXPECT_EQ(1U, processor()->change_list_size());
   EXPECT_FALSE(processor()->ContainsGuid(n1->guid()));
   EXPECT_FALSE(processor()->ContainsGuid(n2->guid()));
   EXPECT_TRUE(processor()->ContainsGuid(n3->guid()));
-  EXPECT_EQ(csync::SyncChange::ACTION_ADD,
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             processor()->GetChangeByGuid(n3->guid()).change_type());
   EXPECT_FALSE(processor()->ContainsGuid(n4->guid()));
 }
 
 // When an item that matches up in model and sync is different, an error
 // should be returned.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocBothNonEmptyTitleMismatch) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(true, 2);
   model()->Add(n2);
 
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(1));
   scoped_ptr<AppNotification> n1_a(CreateNotification(
       n1->is_local(), n1->creation_time().ToInternalValue(),
       n1->guid(), n1->extension_id(),
       n1->title() + "_changed", // different title
       n1->body(), n1->link_url().spec(), n1->link_text()));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n1_a));
 
-  scoped_ptr<csync::SyncErrorFactoryMock> error_handler(
-      new csync::SyncErrorFactoryMock());
+  scoped_ptr<syncer::SyncErrorFactoryMock> error_handler(
+      new syncer::SyncErrorFactoryMock());
   EXPECT_CALL(*error_handler, CreateAndUploadError(_, _)).
       WillOnce(
           Return(
-              csync::SyncError(
+              syncer::SyncError(
                   FROM_HERE, "error", syncable::APP_NOTIFICATIONS)));
 
-  csync::SyncError sync_error = model()->MergeDataAndStartSyncing(
+  syncer::SyncError sync_error = model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
-      error_handler.PassAs<csync::SyncErrorFactory>());
+      error_handler.PassAs<syncer::SyncErrorFactory>());
 
   EXPECT_TRUE(sync_error.IsSet());
   EXPECT_EQ(syncable::APP_NOTIFICATIONS, sync_error.type());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // When an item in sync matches with a local-only item in model, an error
 // should be returned.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocBothNonEmptyMatchesLocal) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(true, 2);
   model()->Add(n2);
 
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(1));
   scoped_ptr<AppNotification> n2_a(CreateNotification(2));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n2_a));
 
-  scoped_ptr<csync::SyncErrorFactoryMock> error_handler(
-      new csync::SyncErrorFactoryMock());
+  scoped_ptr<syncer::SyncErrorFactoryMock> error_handler(
+      new syncer::SyncErrorFactoryMock());
   EXPECT_CALL(*error_handler, CreateAndUploadError(_, _)).
       WillOnce(
           Return(
-              csync::SyncError(
+              syncer::SyncError(
                   FROM_HERE, "error", syncable::APP_NOTIFICATIONS)));
 
-  csync::SyncError sync_error = model()->MergeDataAndStartSyncing(
+  syncer::SyncError sync_error = model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
-      error_handler.PassAs<csync::SyncErrorFactory>());
+      error_handler.PassAs<syncer::SyncErrorFactory>());
 
   EXPECT_TRUE(sync_error.IsSet());
   EXPECT_EQ(syncable::APP_NOTIFICATIONS, sync_error.type());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // Process sync changes when model is empty.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesEmptyModel) {
   // We initially have no data.
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),
+      syncer::SyncDataList(),
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Set up a bunch of ADDs.
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_ADD, CreateNotification(1)));
+      syncer::SyncChange::ACTION_ADD, CreateNotification(1)));
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_ADD, CreateNotification(2)));
+      syncer::SyncChange::ACTION_ADD, CreateNotification(2)));
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_ADD, CreateNotification(3)));
+      syncer::SyncChange::ACTION_ADD, CreateNotification(3)));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 // Process sync changes when model is not empty.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesNonEmptyModel) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),
+      syncer::SyncDataList(),
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Some adds and some deletes.
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_ADD, CreateNotification(3)));
+      syncer::SyncChange::ACTION_ADD, CreateNotification(3)));
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_DELETE, n1->Copy()));
+      syncer::SyncChange::ACTION_DELETE, n1->Copy()));
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_ADD, CreateNotification(4)));
+      syncer::SyncChange::ACTION_ADD, CreateNotification(4)));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2U, processor()->change_list_size());
 }
 
 // Process sync changes should ignore a bad ADD.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesIgnoreBadAdd) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),
+      syncer::SyncDataList(),
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Some adds and some deletes.
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_ADD, CreateNotification(1)));
+      syncer::SyncChange::ACTION_ADD, CreateNotification(1)));
 
-  csync::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
+  syncer::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_FALSE(error.IsSet());
 
   EXPECT_EQ(2U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2U, processor()->change_list_size());
 }
 
 // Process sync changes should ignore a bad DELETE.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesIgnoreBadDelete) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),
+      syncer::SyncDataList(),
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Some adds and some deletes.
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_DELETE, CreateNotification(3)));
+      syncer::SyncChange::ACTION_DELETE, CreateNotification(3)));
 
-  csync::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
+  syncer::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_FALSE(error.IsSet());
 
   EXPECT_EQ(2U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2U, processor()->change_list_size());
 }
 
 // Process sync changes should ignore bad UPDATEs.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesIgnoreBadUpdates) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),
+      syncer::SyncDataList(),
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Some adds and some deletes.
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_UPDATE, CreateNotification(3)));
+      syncer::SyncChange::ACTION_UPDATE, CreateNotification(3)));
   AppNotification* n2_changed = n2->Copy();
   n2_changed->set_link_text(n2_changed->link_text() + "-changed");
   changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_UPDATE, n2_changed));
+      syncer::SyncChange::ACTION_UPDATE, n2_changed));
 
-  csync::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
+  syncer::SyncError error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_FALSE(error.IsSet());
 
   EXPECT_EQ(2U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2U, processor()->change_list_size());
 }
 
 // Process over 15 changes when model is not empty.
 TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesEmptyModelWithMax) {
   const std::string& ext_id = "e1";
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),
+      syncer::SyncDataList(),
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
   for (unsigned int i = 0;
        i < AppNotificationManager::kMaxNotificationPerApp * 2; i++) {
-    csync::SyncChangeList changes;
+    syncer::SyncChangeList changes;
     changes.push_back(CreateSyncChange(
-      csync::SyncChange::ACTION_ADD, CreateNotification(false, i, ext_id)));
+      syncer::SyncChange::ACTION_ADD, CreateNotification(false, i, ext_id)));
     model()->ProcessSyncChanges(FROM_HERE, changes);
     if (i < AppNotificationManager::kMaxNotificationPerApp) {
       EXPECT_EQ(i + 1,
                 model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
     } else {
       EXPECT_EQ(AppNotificationManager::kMaxNotificationPerApp,
         model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
       for (unsigned int j = i; j > i - 5; j--) {
         EXPECT_EQ(
             AppNotificationManager::kMaxNotificationPerApp,
             model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
       }
     }
   }
 }
 
 // Stop syncing sets state correctly.
 TEST_F(AppNotificationManagerSyncTest, StopSyncing) {
   EXPECT_FALSE(model()->sync_processor_.get());
   EXPECT_FALSE(model()->models_associated_);
 
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),
+      syncer::SyncDataList(),
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_TRUE(model()->sync_processor_.get());
   EXPECT_TRUE(model()->models_associated_);
 
   model()->StopSyncing(syncable::APP_NOTIFICATIONS);
   EXPECT_FALSE(model()->sync_processor_.get());
   EXPECT_FALSE(model()->models_associated_);
 }
 
 // Adds get pushed to sync but local only are skipped.
 TEST_F(AppNotificationManagerSyncTest, AddsGetsSynced) {
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
-      csync::SyncDataList(),
+      syncer::SyncDataList(),
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(2);
   model()->Add(n2);
   AppNotification* n3 = CreateNotification(true, 2);
   model()->Add(n3);
 
   EXPECT_EQ(2U, processor()->change_list_size());
   EXPECT_TRUE(processor()->ContainsGuid(n1->guid()));
-  csync::SyncChange c1 = processor()->GetChangeByGuid(n1->guid());
-  AssertSyncChange(c1, csync::SyncChange::ACTION_ADD, *n1);
-  csync::SyncChange c2 = processor()->GetChangeByGuid(n2->guid());
-  AssertSyncChange(c2, csync::SyncChange::ACTION_ADD, *n2);
+  syncer::SyncChange c1 = processor()->GetChangeByGuid(n1->guid());
+  AssertSyncChange(c1, syncer::SyncChange::ACTION_ADD, *n1);
+  syncer::SyncChange c2 = processor()->GetChangeByGuid(n2->guid());
+  AssertSyncChange(c2, syncer::SyncChange::ACTION_ADD, *n2);
 }
 
 // Clear all gets pushed to sync.
 TEST_F(AppNotificationManagerSyncTest, ClearAllGetsSynced) {
   const std::string& ext_id = "e1";
   scoped_ptr<AppNotification> n1(CreateNotification(false, 1, ext_id));
   scoped_ptr<AppNotification> n2(CreateNotification(false, 2, ext_id));
   scoped_ptr<AppNotification> n3(CreateNotification(false, 3, ext_id));
   scoped_ptr<AppNotification> n4(CreateNotification(4));
 
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n1));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n2));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n3));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n4));
   model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
       initial_data,
       PassProcessor(),
-      scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock()));
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   model()->ClearAll(ext_id);
 
   EXPECT_EQ(3U, processor()->change_list_size());
   EXPECT_TRUE(processor()->ContainsGuid(n1->guid()));
-  csync::SyncChange c1 = processor()->GetChangeByGuid(n1->guid());
-  AssertSyncChange(c1, csync::SyncChange::ACTION_DELETE, *n1);
-  csync::SyncChange c2 = processor()->GetChangeByGuid(n2->guid());
-  AssertSyncChange(c2, csync::SyncChange::ACTION_DELETE, *n2);
-  csync::SyncChange c3 = processor()->GetChangeByGuid(n3->guid());
-  AssertSyncChange(c3, csync::SyncChange::ACTION_DELETE, *n3);
+  syncer::SyncChange c1 = processor()->GetChangeByGuid(n1->guid());
+  AssertSyncChange(c1, syncer::SyncChange::ACTION_DELETE, *n1);
+  syncer::SyncChange c2 = processor()->GetChangeByGuid(n2->guid());
+  AssertSyncChange(c2, syncer::SyncChange::ACTION_DELETE, *n2);
+  syncer::SyncChange c3 = processor()->GetChangeByGuid(n3->guid());
+  AssertSyncChange(c3, syncer::SyncChange::ACTION_DELETE, *n3);
 }