[Sync] Rename csync namespace to syncer

chrome/browser/search_engines/template_url_service_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/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
@@ skipping 12 matching lines @@
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/protocol/search_engine_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
 
-// Extract the GUID from a search engine csync::SyncData.
-std::string GetGUID(const csync::SyncData& sync_data) {
+// Extract the GUID from a search engine syncer::SyncData.
+std::string GetGUID(const syncer::SyncData& sync_data) {
   return sync_data.GetSpecifics().search_engine().sync_guid();
 }
 
-// Extract the URL from a search engine csync::SyncData.
-std::string GetURL(const csync::SyncData& sync_data) {
+// Extract the URL from a search engine syncer::SyncData.
+std::string GetURL(const syncer::SyncData& sync_data) {
   return sync_data.GetSpecifics().search_engine().url();
 }
 
-// Extract the keyword from a search engine csync::SyncData.
-std::string GetKeyword(const csync::SyncData& sync_data) {
+// Extract the keyword from a search engine syncer::SyncData.
+std::string GetKeyword(const syncer::SyncData& sync_data) {
   return sync_data.GetSpecifics().search_engine().keyword();
 }
 
 // Much like TemplateURLService::CreateSyncDataFromTemplateURL(), but allows the
 // caller to override the keyword, URL, or GUID fields with empty strings, in
 // order to create custom data that should be handled specially when synced to a
 // client.
-csync::SyncData CreateCustomSyncData(const TemplateURL& turl,
+syncer::SyncData CreateCustomSyncData(const TemplateURL& turl,
                               bool autogenerate_keyword,
                               const std::string& url,
                               const std::string& sync_guid) {
   sync_pb::EntitySpecifics specifics;
   sync_pb::SearchEngineSpecifics* se_specifics =
       specifics.mutable_search_engine();
   se_specifics->set_short_name(UTF16ToUTF8(turl.short_name()));
   se_specifics->set_keyword(
       autogenerate_keyword ? std::string() : UTF16ToUTF8(turl.keyword()));
   se_specifics->set_favicon_url(turl.favicon_url().spec());
   se_specifics->set_url(url);
   se_specifics->set_safe_for_autoreplace(turl.safe_for_autoreplace());
   se_specifics->set_originating_url(turl.originating_url().spec());
   se_specifics->set_date_created(turl.date_created().ToInternalValue());
   se_specifics->set_input_encodings(JoinString(turl.input_encodings(), ';'));
   se_specifics->set_show_in_default_list(turl.show_in_default_list());
   se_specifics->set_suggestions_url(turl.suggestions_url());
   se_specifics->set_prepopulate_id(turl.prepopulate_id());
   se_specifics->set_autogenerate_keyword(autogenerate_keyword);
   se_specifics->set_instant_url(turl.instant_url());
   se_specifics->set_last_modified(turl.last_modified().ToInternalValue());
   se_specifics->set_sync_guid(sync_guid);
-  return csync::SyncData::CreateLocalData(turl.sync_guid(),  // Must be valid!
+  return syncer::SyncData::CreateLocalData(turl.sync_guid(),  // Must be valid!
                                    se_specifics->keyword(), specifics);
 }
 
 
 // TestChangeProcessor --------------------------------------------------------
 
 // 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) OVERRIDE;
+      const syncer::SyncChangeList& change_list) OVERRIDE;
 
   bool contains_guid(const std::string& guid) const {
     return change_map_.count(guid) != 0;
   }
 
-  csync::SyncChange change_for_guid(const std::string& guid) const {
+  syncer::SyncChange change_for_guid(const std::string& guid) const {
     DCHECK(contains_guid(guid));
     return change_map_.find(guid)->second;
   }
 
   size_t change_list_size() { return change_map_.size(); }
 
   void set_erroneous(bool erroneous) { erroneous_ = erroneous; }
 
  private:
   // Track the changes received in ProcessSyncChanges.
-  std::map<std::string, csync::SyncChange> change_map_;
+  std::map<std::string, syncer::SyncChange> change_map_;
   bool erroneous_;
 
   DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor);
 };
 
 TestChangeProcessor::TestChangeProcessor() : erroneous_(false) {
 }
 
 TestChangeProcessor::~TestChangeProcessor() {
 }
 
-csync::SyncError TestChangeProcessor::ProcessSyncChanges(
+syncer::SyncError TestChangeProcessor::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const csync::SyncChangeList& change_list) {
+    const syncer::SyncChangeList& change_list) {
   if (erroneous_)
-    return csync::SyncError(FROM_HERE, "Some error.", syncable::SEARCH_ENGINES);
+    return syncer::SyncError(
+        FROM_HERE, "Some error.", syncable::SEARCH_ENGINES);
 
   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();
 }
 
 
 // SyncChangeProcessorDelegate ------------------------------------------------
 
-class SyncChangeProcessorDelegate : public csync::SyncChangeProcessor {
+class SyncChangeProcessorDelegate : public syncer::SyncChangeProcessor {
  public:
-  explicit SyncChangeProcessorDelegate(csync::SyncChangeProcessor* recipient);
+  explicit SyncChangeProcessorDelegate(syncer::SyncChangeProcessor* 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;
 
  private:
   // The recipient of all sync changes.
-  csync::SyncChangeProcessor* recipient_;
+  syncer::SyncChangeProcessor* recipient_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncChangeProcessorDelegate);
 };
 
 SyncChangeProcessorDelegate::SyncChangeProcessorDelegate(
-    csync::SyncChangeProcessor* recipient)
+    syncer::SyncChangeProcessor* recipient)
     : recipient_(recipient) {
   DCHECK(recipient_);
 }
 
 SyncChangeProcessorDelegate::~SyncChangeProcessorDelegate() {
 }
 
-csync::SyncError SyncChangeProcessorDelegate::ProcessSyncChanges(
+syncer::SyncError SyncChangeProcessorDelegate::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const csync::SyncChangeList& change_list) {
+    const syncer::SyncChangeList& change_list) {
   return recipient_->ProcessSyncChanges(from_here, change_list);
 }
 
 }  // namespace
 
 
 // TemplateURLServiceSyncTest -------------------------------------------------
 
 class TemplateURLServiceSyncTest : public testing::Test {
  public:
   typedef TemplateURLService::SyncDataMap SyncDataMap;
 
   TemplateURLServiceSyncTest();
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   TemplateURLService* model() { return test_util_a_.model(); }
   // For readability, we redefine an accessor for Model A for use in tests that
   // involve syncing two models.
   TemplateURLService* model_a() { return test_util_a_.model(); }
   TemplateURLService* model_b() { return model_b_.get(); }
   TestingProfile* profile_a() { return test_util_a_.profile(); }
   TestChangeProcessor* processor() { return sync_processor_.get(); }
-  scoped_ptr<csync::SyncChangeProcessor> PassProcessor();
-  scoped_ptr<csync::SyncErrorFactory> CreateAndPassSyncErrorFactory();
+  scoped_ptr<syncer::SyncChangeProcessor> PassProcessor();
+  scoped_ptr<syncer::SyncErrorFactory> CreateAndPassSyncErrorFactory();
 
   // Create a TemplateURL with some test values. The caller owns the returned
   // TemplateURL*.
   TemplateURL* CreateTestTemplateURL(const string16& keyword,
                                      const std::string& url,
                                      const std::string& guid = std::string(),
                                      time_t last_mod = 100,
                                      bool safe_for_autoreplace = false,
                                      bool created_by_policy = false) const;
 
   // Verifies the two TemplateURLs are equal.
   // TODO(stevet): Share this with TemplateURLServiceTest.
   void AssertEquals(const TemplateURL& expected,
                     const TemplateURL& actual) const;
 
-  // Expect that two csync::SyncDataLists have equal contents, in terms of the
+  // Expect that two syncer::SyncDataLists have equal contents, in terms of the
   // sync_guid, keyword, and url fields.
-  void AssertEquals(const csync::SyncDataList& data1,
-                    const csync::SyncDataList& data2) const;
+  void AssertEquals(const syncer::SyncDataList& data1,
+                    const syncer::SyncDataList& data2) const;
 
   // Convenience helper for creating SyncChanges. Takes ownership of |turl|.
-  csync::SyncChange CreateTestSyncChange(csync::SyncChange::SyncChangeType type,
-                                  TemplateURL* turl) const;
+  syncer::SyncChange CreateTestSyncChange(
+      syncer::SyncChange::SyncChangeType type,
+      TemplateURL* turl) const;
 
   // Helper that creates some initial sync data. We cheat a little by specifying
   // GUIDs for easy identification later. We also make the last_modified times
   // slightly older than CreateTestTemplateURL's default, to test conflict
   // resolution.
-  csync::SyncDataList CreateInitialSyncData() const;
+  syncer::SyncDataList CreateInitialSyncData() const;
 
   // Syntactic sugar.
-  TemplateURL* Deserialize(const csync::SyncData& sync_data);
+  TemplateURL* Deserialize(const syncer::SyncData& sync_data);
 
  protected:
   // We keep two TemplateURLServices to test syncing between them.
   TemplateURLServiceTestUtil test_util_a_;
   scoped_ptr<TestingProfile> profile_b_;
   scoped_ptr<TemplateURLService> model_b_;
 
   // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
   scoped_ptr<TestChangeProcessor> sync_processor_;
   scoped_ptr<SyncChangeProcessorDelegate> sync_processor_delegate_;
@@ skipping 17 matching lines @@
   TemplateURLServiceFactory::GetInstance()->RegisterUserPrefsOnProfile(
       profile_b_.get());
   model_b_.reset(new TemplateURLService(profile_b_.get()));
   model_b_->Load();
 }
 
 void TemplateURLServiceSyncTest::TearDown() {
   test_util_a_.TearDown();
 }
 
-scoped_ptr<csync::SyncChangeProcessor>
+scoped_ptr<syncer::SyncChangeProcessor>
 TemplateURLServiceSyncTest::PassProcessor() {
-  return sync_processor_delegate_.PassAs<csync::SyncChangeProcessor>();
+  return sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>();
 }
 
-scoped_ptr<csync::SyncErrorFactory> TemplateURLServiceSyncTest::
+scoped_ptr<syncer::SyncErrorFactory> TemplateURLServiceSyncTest::
     CreateAndPassSyncErrorFactory() {
-  return scoped_ptr<csync::SyncErrorFactory>(new csync::SyncErrorFactoryMock());
+  return scoped_ptr<syncer::SyncErrorFactory>(
+      new syncer::SyncErrorFactoryMock());
 }
 
 TemplateURL* TemplateURLServiceSyncTest::CreateTestTemplateURL(
     const string16& keyword,
     const std::string& url,
     const std::string& guid,
     time_t last_mod,
     bool safe_for_autoreplace,
     bool created_by_policy) const {
   TemplateURLData data;
@@ skipping 19 matching lines @@
   ASSERT_EQ(expected.suggestions_url(), actual.suggestions_url());
   ASSERT_EQ(expected.favicon_url(), actual.favicon_url());
   ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
   ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace());
   ASSERT_EQ(expected.input_encodings(), actual.input_encodings());
   ASSERT_EQ(expected.date_created(), actual.date_created());
   ASSERT_EQ(expected.last_modified(), actual.last_modified());
 }
 
 void TemplateURLServiceSyncTest::AssertEquals(
-    const csync::SyncDataList& data1,
-    const csync::SyncDataList& data2) const {
+    const syncer::SyncDataList& data1,
+    const syncer::SyncDataList& data2) const {
   SyncDataMap map1 = TemplateURLService::CreateGUIDToSyncDataMap(data1);
   SyncDataMap map2 = TemplateURLService::CreateGUIDToSyncDataMap(data2);
 
   for (SyncDataMap::const_iterator iter1 = map1.begin();
       iter1 != map1.end(); iter1++) {
     SyncDataMap::iterator iter2 = map2.find(iter1->first);
     if (iter2 != map2.end()) {
       ASSERT_EQ(GetKeyword(iter1->second), GetKeyword(iter2->second));
       ASSERT_EQ(GetURL(iter1->second), GetURL(iter2->second));
       map2.erase(iter2);
     }
   }
   EXPECT_EQ(0U, map2.size());
 }
 
-csync::SyncChange TemplateURLServiceSyncTest::CreateTestSyncChange(
-    csync::SyncChange::SyncChangeType type,
+syncer::SyncChange TemplateURLServiceSyncTest::CreateTestSyncChange(
+    syncer::SyncChange::SyncChangeType type,
     TemplateURL* turl) const {
   // We take control of the TemplateURL so make sure it's cleaned up after
   // we create data out of it.
   scoped_ptr<TemplateURL> scoped_turl(turl);
-  return csync::SyncChange(type,
+  return syncer::SyncChange(type,
       TemplateURLService::CreateSyncDataFromTemplateURL(*scoped_turl));
 }
 
-csync::SyncDataList TemplateURLServiceSyncTest::CreateInitialSyncData() const {
-  csync::SyncDataList list;
+syncer::SyncDataList TemplateURLServiceSyncTest::CreateInitialSyncData() const {
+  syncer::SyncDataList list;
 
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com", "key1", 90));
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com",
                                    "key2", 90));
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com",
                                    "key3", 90));
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
 
   return list;
 }
 
 TemplateURL* TemplateURLServiceSyncTest::Deserialize(
-    const csync::SyncData& sync_data) {
-  csync::SyncChangeList dummy;
+    const syncer::SyncData& sync_data) {
+  syncer::SyncChangeList dummy;
   return TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(NULL,
       NULL, sync_data, &dummy);
 }
 
 
 // Actual tests ---------------------------------------------------------------
 
 TEST_F(TemplateURLServiceSyncTest, SerializeDeserialize) {
   // Create a TemplateURL and convert it into a sync specific type.
   scoped_ptr<TemplateURL> turl(
       CreateTestTemplateURL(
           ASCIIToUTF16("unittest"), "http://www.unittest.com/"));
-  csync::SyncData sync_data =
+  syncer::SyncData sync_data =
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
   // Convert the specifics back to a TemplateURL.
   scoped_ptr<TemplateURL> deserialized(Deserialize(sync_data));
   EXPECT_TRUE(deserialized.get());
   // Ensure that the original and the deserialized TURLs are equal in values.
   AssertEquals(*turl, *deserialized);
 }
 
 TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataBasic) {
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com"));
-  csync::SyncDataList all_sync_data =
+  syncer::SyncDataList all_sync_data =
       model()->GetAllSyncData(syncable::SEARCH_ENGINES);
 
   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) {
     std::string guid = GetGUID(*iter);
     const TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
     scoped_ptr<TemplateURL> deserialized(Deserialize(*iter));
     AssertEquals(*service_turl, *deserialized);
   }
 }
 
 TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataNoExtensions) {
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key3"),
       std::string(chrome::kExtensionScheme) + "://blahblahblah"));
-  csync::SyncDataList all_sync_data =
+  syncer::SyncDataList all_sync_data =
       model()->GetAllSyncData(syncable::SEARCH_ENGINES);
 
   EXPECT_EQ(2U, 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) {
     std::string guid = GetGUID(*iter);
     const TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
     scoped_ptr<TemplateURL> deserialized(Deserialize(*iter));
     AssertEquals(*service_turl, *deserialized);
   }
 }
 
 TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataNoManagedEngines) {
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
   TemplateURL* managed_turl = CreateTestTemplateURL(ASCIIToUTF16("key3"),
       "http://key3.com", std::string(), 100, false, true);
   model()->Add(managed_turl);
-  csync::SyncDataList all_sync_data =
+  syncer::SyncDataList all_sync_data =
       model()->GetAllSyncData(syncable::SEARCH_ENGINES);
 
   EXPECT_EQ(2U, 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) {
     std::string guid = GetGUID(*iter);
     TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
     scoped_ptr<TemplateURL> deserialized(Deserialize(*iter));
     ASSERT_FALSE(service_turl->created_by_policy());
     AssertEquals(*service_turl, *deserialized);
   }
 }
 
 TEST_F(TemplateURLServiceSyncTest, UniquifyKeyword) {
@@ skipping 22 matching lines @@
   new_keyword = model()->UniquifyKeyword(*turl);
   EXPECT_EQ(ASCIIToUTF16("key1__"), new_keyword);
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncKeywordConflictNeitherAutoreplace) {
   // This tests cases where neither the sync nor the local TemplateURL are
   // marked safe_for_autoreplace.
 
   // Create a keyword that conflicts, and make it older.  Sync keyword is
-  // uniquified, and a csync::SyncChange is added.
+  // uniquified, and a syncer::SyncChange is added.
   string16 original_turl_keyword = ASCIIToUTF16("key1");
   TemplateURL* original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", std::string(), 9000);
   model()->Add(original_turl);
   scoped_ptr<TemplateURL> sync_turl(CreateTestTemplateURL(original_turl_keyword,
       "http://new.com", "remote", 8999));
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
   EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                   original_turl, &changes));
   EXPECT_NE(original_turl_keyword, sync_turl->keyword());
   EXPECT_EQ(original_turl_keyword, original_turl->keyword());
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("remote", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // Sync is newer.  Original TemplateURL keyword is uniquified.  A SyncChange
   // is added (which in a normal run would be deleted by PruneSyncChanges() when
   // the local GUID doesn't appear in the sync GUID list).  Also ensure that
   // this does not change the safe_for_autoreplace flag or the TemplateURLID in
   // the original.
   original_turl = CreateTestTemplateURL(original_turl_keyword,
                                         "http://key1.com", "local", 9000);
   model()->Add(original_turl);
   TemplateURLID original_id = original_turl->id();
   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
                                         std::string(), 9001));
   EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                   original_turl, &changes));
   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
   EXPECT_NE(original_turl_keyword, original_turl->keyword());
   EXPECT_FALSE(original_turl->safe_for_autoreplace());
   EXPECT_EQ(original_id, original_turl->id());
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(original_turl_keyword));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("local", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // Equal times. Same result as above. Sync left alone, original uniquified so
   // sync_turl can fit.
   original_turl = CreateTestTemplateURL(original_turl_keyword,
                                         "http://key1.com", "local2", 9000);
   model()->Add(original_turl);
   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
                                         std::string(), 9000));
   EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                   original_turl, &changes));
   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
   EXPECT_NE(original_turl_keyword, original_turl->keyword());
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(original_turl_keyword));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("local2", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // Sync is newer, but original TemplateURL is created by policy, so it wins.
-  // Sync keyword is uniquified, and a csync::SyncChange is added.
+  // Sync keyword is uniquified, and a syncer::SyncChange is added.
   original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", std::string(), 9000, false, true);
   model()->Add(original_turl);
   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
                                         "remote2", 9999));
   EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                   original_turl, &changes));
   EXPECT_NE(original_turl_keyword, sync_turl->keyword());
   EXPECT_EQ(original_turl_keyword, original_turl->keyword());
   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(sync_turl->keyword()));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("remote2", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncKeywordConflictBothAutoreplace) {
   // This tests cases where both the sync and the local TemplateURL are marked
   // safe_for_autoreplace.
 
   // Create a keyword that conflicts, and make it older.  SyncChange is added,
   // function returns false.
   string16 original_turl_keyword = ASCIIToUTF16("key1");
   TemplateURL* original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", std::string(), 9000, true);
   model()->Add(original_turl);
   scoped_ptr<TemplateURL> sync_turl(CreateTestTemplateURL(original_turl_keyword,
       "http://new.com", "remote", 8999, true));
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
   EXPECT_FALSE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                    original_turl, &changes));
   EXPECT_EQ(original_turl,
             model()->GetTemplateURLForKeyword(original_turl_keyword));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("remote", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // Sync is newer.  Original TemplateURL is removed from the model.  A
-  // csync::SyncChange is added (which in a normal run would be deleted by
+  // syncer::SyncChange is added (which in a normal run would be deleted by
   // PruneSyncChanges() when the local GUID doesn't appear in the sync GUID
   // list).
   original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", "local", 9000, true);
   model()->Add(original_turl);
   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
                                         std::string(), 9001, true));
   EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                   original_turl, &changes));
   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
   EXPECT_TRUE(model()->GetTemplateURLs().empty());
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("local", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[0].change_type());
   changes.clear();
 
   // Equal times. Same result as above. Sync left alone, original removed so
   // sync_turl can fit.
   original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", "local2", 9000, true);
   model()->Add(original_turl);
   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
                                         std::string(), 9000, true));
   EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                   original_turl, &changes));
   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
   EXPECT_TRUE(model()->GetTemplateURLs().empty());
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("local2", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[0].change_type());
   changes.clear();
 
   // Sync is newer, but original TemplateURL is created by policy, so it wins.
-  // csync::SyncChange is added, function returns false.
+  // syncer::SyncChange is added, function returns false.
   original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", std::string(), 9000, true, true);
   model()->Add(original_turl);
   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
                                         "remote2", 9999, true));
   EXPECT_FALSE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                    original_turl, &changes));
   EXPECT_EQ(original_turl,
             model()->GetTemplateURLForKeyword(original_turl_keyword));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("remote2", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncKeywordConflictOneAutoreplace) {
   // This tests cases where either the sync or the local TemplateURL is marked
   // safe_for_autoreplace, but the other is not.  Basically, we run the same
   // tests as in SyncKeywordConflictBothAutoreplace, but mark the keywords so as
   // to reverse the outcome of each test.
 
   // Create a keyword that conflicts, and make it older.  Normally the local
   // TemplateURL would win this.
   string16 original_turl_keyword = ASCIIToUTF16("key1");
   TemplateURL* original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", "local", 9000, true);
   model()->Add(original_turl);
   scoped_ptr<TemplateURL> sync_turl(CreateTestTemplateURL(original_turl_keyword,
       "http://new.com", std::string(), 8999));
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
   EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                   original_turl, &changes));
   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
   EXPECT_TRUE(model()->GetTemplateURLs().empty());
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("local", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[0].change_type());
   changes.clear();
 
   // Sync is newer.  Normally the sync TemplateURL would win this.
   original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", std::string(), 9000);
   model()->Add(original_turl);
   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
                                         "remote", 9001, true));
   EXPECT_FALSE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                    original_turl, &changes));
   EXPECT_EQ(original_turl,
             model()->GetTemplateURLForKeyword(original_turl_keyword));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("remote", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // Equal times. Same result as above.
   original_turl = CreateTestTemplateURL(original_turl_keyword,
       "http://key1.com", std::string(), 9000);
   model()->Add(original_turl);
   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
                                         "remote2", 9000, true));
   EXPECT_FALSE(model()->ResolveSyncKeywordConflict(sync_turl.get(),
                                                    original_turl, &changes));
   EXPECT_EQ(original_turl,
             model()->GetTemplateURLForKeyword(original_turl_keyword));
   ASSERT_EQ(1U, changes.size());
   EXPECT_EQ("remote2", GetGUID(changes[0].sync_data()));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, changes[0].change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[0].change_type());
   changes.clear();
   model()->Remove(original_turl);
 
   // We don't run the "created by policy" test since URLs created by policy are
   // never safe_for_autoreplace.
 }
 
 TEST_F(TemplateURLServiceSyncTest, FindDuplicateOfSyncTemplateURL) {
   TemplateURL* original_turl =
       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com");
@@ skipping 24 matching lines @@
   EXPECT_EQ(dupe_turl->url(), sync_turl->url());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeSyncAndLocalURLDuplicates) {
   TemplateURL* original_turl = CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com", std::string(), 9000);
   model()->Add(original_turl);
   TemplateURL* sync_turl = CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com", std::string(), 9001);
   std::string original_guid = original_turl->sync_guid();
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
 
   // The sync TemplateURL is newer. It should replace the original TemplateURL
-  // and a csync::SyncChange should be added to the list.
+  // and a syncer::SyncChange should be added to the list.
   // Note that MergeSyncAndLocalURLDuplicates takes ownership of sync_turl.
   model()->MergeSyncAndLocalURLDuplicates(sync_turl, original_turl, &changes);
   TemplateURL* result = model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1"));
   ASSERT_TRUE(result);
   EXPECT_EQ(9001, result->last_modified().ToTimeT());
   EXPECT_EQ(1U, changes.size());
   // We expect a change to delete the local entry.
-  csync::SyncChange change = changes.at(0);
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, change.change_type());
+  syncer::SyncChange change = changes.at(0);
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change.change_type());
   EXPECT_EQ(original_guid,
             change.sync_data().GetSpecifics().search_engine().sync_guid());
   changes.clear();
 
   // The sync TemplateURL is older. The existing TemplateURL should win and a
-  // csync::SyncChange should be added to the list.
+  // syncer::SyncChange should be added to the list.
   TemplateURL* sync_turl2 = CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com", std::string(), 8999);
   std::string sync_guid = sync_turl2->sync_guid();
   model()->MergeSyncAndLocalURLDuplicates(sync_turl2, sync_turl, &changes);
   result = model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1"));
   ASSERT_TRUE(result);
   EXPECT_EQ(9001, result->last_modified().ToTimeT());
   EXPECT_EQ(1U, changes.size());
   // We expect a change to update the sync entry.
   change = changes.at(0);
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, change.change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
   EXPECT_EQ(sync_guid,
             change.sync_data().GetSpecifics().search_engine().sync_guid());
 }
 
 TEST_F(TemplateURLServiceSyncTest, StartSyncEmpty) {
   model()->MergeDataAndStartSyncing(
-      syncable::SEARCH_ENGINES, csync::SyncDataList(),
+      syncable::SEARCH_ENGINES, syncer::SyncDataList(),
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(0U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeIntoEmpty) {
-  csync::SyncDataList initial_data = CreateInitialSyncData();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   // We expect the model to have accepted all of the initial sync data. Search
   // through the model using the GUIDs to ensure that they're present.
-  for (csync::SyncDataList::const_iterator iter = initial_data.begin();
+  for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
   }
 
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeInAllNewData) {
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("abc.com"), "http://abc.com",
                                      "abc"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("def.com"), "http://def.com",
                                      "def"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("xyz.com"), "http://xyz.com",
                                      "xyz"));
-  csync::SyncDataList initial_data = CreateInitialSyncData();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(6U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   // We expect the model to have accepted all of the initial sync data. Search
   // through the model using the GUIDs to ensure that they're present.
-  for (csync::SyncDataList::const_iterator iter = initial_data.begin();
+  for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
   }
   // All the original TemplateURLs should also remain in the model.
   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("abc.com")));
   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("def.com")));
   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("xyz.com")));
   // Ensure that Sync received the expected changes.
   EXPECT_EQ(3U, processor()->change_list_size());
   EXPECT_TRUE(processor()->contains_guid("abc"));
   EXPECT_TRUE(processor()->contains_guid("def"));
   EXPECT_TRUE(processor()->contains_guid("xyz"));
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeSyncIsTheSame) {
   // The local data is the same as the sync data merged in. i.e. - There have
   // been no changes since the last time we synced. Even the last_modified
   // timestamps are the same.
-  csync::SyncDataList initial_data = CreateInitialSyncData();
-  for (csync::SyncDataList::const_iterator iter = initial_data.begin();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
+  for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     TemplateURL* converted = Deserialize(*iter);
     model()->Add(converted);
   }
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
-  for (csync::SyncDataList::const_iterator iter = initial_data.begin();
+  for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
   }
   EXPECT_EQ(0U, processor()->change_list_size());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeUpdateFromSync) {
   // The local data is the same as the sync data merged in, but timestamps have
   // changed. Ensure the right fields are merged in.
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   TemplateURL* turl1 = CreateTestTemplateURL(ASCIIToUTF16("abc.com"),
                                              "http://abc.com", "abc", 9000);
   model()->Add(turl1);
   TemplateURL* turl2 = CreateTestTemplateURL(ASCIIToUTF16("xyz.com"),
                                              "http://xyz.com", "xyz", 9000);
   model()->Add(turl2);
 
   scoped_ptr<TemplateURL> turl1_newer(CreateTestTemplateURL(
       ASCIIToUTF16("abc.com"), "http://abc.ca", "abc", 9999));
   initial_data.push_back(
@@ skipping 10 matching lines @@
   // Both were local updates, so we expect the same count.
   EXPECT_EQ(2U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
 
   // Check that the first replaced the initial abc TemplateURL.
   EXPECT_EQ(turl1, model()->GetTemplateURLForGUID("abc"));
   EXPECT_EQ("http://abc.ca", turl1->url());
 
   // Check that the second produced an upstream update to the xyz TemplateURL.
   EXPECT_EQ(1U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("xyz"));
-  csync::SyncChange change = processor()->change_for_guid("xyz");
-  EXPECT_TRUE(change.change_type() == csync::SyncChange::ACTION_UPDATE);
+  syncer::SyncChange change = processor()->change_for_guid("xyz");
+  EXPECT_TRUE(change.change_type() == syncer::SyncChange::ACTION_UPDATE);
   EXPECT_EQ("http://xyz.com", GetURL(change.sync_data()));
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeAddFromOlderSyncData) {
   // GUIDs all differ, so this is data to be added from Sync, but the timestamps
   // from Sync are older. Set up the local data so that one is a dupe, one has a
   // conflicting keyword, and the last has no conflicts (a clean ADD).
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
                                      "aaa", 100));  // dupe
 
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "http://expected.com", "bbb", 100));  // keyword conflict
 
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("unique"),
                                      "http://unique.com", "ccc"));  // add
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                     CreateInitialSyncData(), PassProcessor(),
                                     CreateAndPassSyncErrorFactory());
 
   // The dupe results in a merge. The other two should be added to the model.
   EXPECT_EQ(5U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
 
   // The key1 duplicate results in the local copy winning. Ensure that Sync's
   // copy was not added, and the local copy is pushed upstream to Sync as an
   // update. The local copy should have received the sync data's GUID.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   // Check changes for the UPDATE.
   ASSERT_TRUE(processor()->contains_guid("key1"));
-  csync::SyncChange key1_change = processor()->change_for_guid("key1");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, key1_change.change_type());
+  syncer::SyncChange key1_change = processor()->change_for_guid("key1");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key1_change.change_type());
   EXPECT_FALSE(model()->GetTemplateURLForGUID("aaa"));
 
   // The key2 keyword conflict results in the local copy winning, so ensure it
   // retains the original keyword, and that an update to the sync copy is pushed
   // upstream to Sync. Both TemplateURLs should be found locally, however.
   const TemplateURL* key2 = model()->GetTemplateURLForGUID("bbb");
   EXPECT_TRUE(key2);
   EXPECT_EQ(ASCIIToUTF16("key2"), key2->keyword());
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   // Check changes for the UPDATE.
   ASSERT_TRUE(processor()->contains_guid("key2"));
-  csync::SyncChange key2_change = processor()->change_for_guid("key2");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, key2_change.change_type());
+  syncer::SyncChange key2_change = processor()->change_for_guid("key2");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key2_change.change_type());
   EXPECT_EQ("key2.com", GetKeyword(key2_change.sync_data()));
 
   // The last TemplateURL should have had no conflicts and was just added. It
   // should not have replaced the third local TemplateURL.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("ccc"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
 
   // Two UPDATEs and two ADDs.
   EXPECT_EQ(4U, processor()->change_list_size());
   // Two ADDs should be pushed up to Sync.
   ASSERT_TRUE(processor()->contains_guid("bbb"));
-  EXPECT_EQ(csync::SyncChange::ACTION_ADD,
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             processor()->change_for_guid("bbb").change_type());
   ASSERT_TRUE(processor()->contains_guid("ccc"));
-  EXPECT_EQ(csync::SyncChange::ACTION_ADD,
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             processor()->change_for_guid("ccc").change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeAddFromNewerSyncData) {
   // GUIDs all differ, so this is data to be added from Sync, but the timestamps
   // from Sync are newer. Set up the local data so that one is a dupe, one has a
   // conflicting keyword, and the last has no conflicts (a clean ADD).
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
                                      "aaa", 10));  // dupe
 
@@ skipping 27 matching lines @@
 
   // The last TemplateURL should have had no conflicts and was just added. It
   // should not have replaced the third local TemplateURL.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("ccc"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
 
   // Two ADDs.
   EXPECT_EQ(2U, processor()->change_list_size());
   // Two ADDs should be pushed up to Sync.
   ASSERT_TRUE(processor()->contains_guid("bbb"));
-  EXPECT_EQ(csync::SyncChange::ACTION_ADD,
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             processor()->change_for_guid("bbb").change_type());
   ASSERT_TRUE(processor()->contains_guid("ccc"));
-  EXPECT_EQ(csync::SyncChange::ACTION_ADD,
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             processor()->change_for_guid("ccc").change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesEmptyModel) {
   // We initially have no data.
   model()->MergeDataAndStartSyncing(
-      syncable::SEARCH_ENGINES, csync::SyncDataList(),
+      syncable::SEARCH_ENGINES, syncer::SyncDataList(),
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Set up a bunch of ADDs.
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1")));
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com", "key2")));
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key3")));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_EQ(0U, processor()->change_list_size());
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesNoConflicts) {
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                     CreateInitialSyncData(), PassProcessor(),
                                     CreateAndPassSyncErrorFactory());
 
   // Process different types of changes, without conflicts.
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key4"), "http://key4.com", "key4")));
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_UPDATE,
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
                             "key2")));
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_DELETE,
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_DELETE,
       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key3")));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   // Add one, remove one, update one, so the number shouldn't change.
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_EQ(0U, processor()->change_list_size());
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   const TemplateURL* turl = model()->GetTemplateURLForGUID("key2");
   EXPECT_TRUE(turl);
   EXPECT_EQ(ASCIIToUTF16("newkeyword"), turl->keyword());
   EXPECT_EQ("http://new.com", turl->url());
   EXPECT_FALSE(model()->GetTemplateURLForGUID("key3"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key4"));
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithConflictsSyncWins) {
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                     CreateInitialSyncData(), PassProcessor(),
                                     CreateAndPassSyncErrorFactory());
 
   // Process different types of changes, with conflicts. Note that all this data
   // has a newer timestamp, so Sync will win in these scenarios.
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://new.com", "aaa")));
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_UPDATE,
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key1")));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   // Add one, update one, so we're up to 4.
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   // Sync is always newer here, so it should always win.  We should create
   // SyncChanges for the changes to the local entities, since they're synced
   // too.
   EXPECT_EQ(2U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("key2"));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE,
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             processor()->change_for_guid("key2").change_type());
   ASSERT_TRUE(processor()->contains_guid("key3"));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE,
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             processor()->change_for_guid("key3").change_type());
 
   // aaa conflicts with key2 and wins, forcing key2's keyword to update.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("aaa"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("aaa"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key2")));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("key2"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key2.com")));
   // key1 update conflicts with key3 and wins, forcing key3's keyword to update.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("key1"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3")));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("key3"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3.com")));
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithConflictsLocalWins) {
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                     CreateInitialSyncData(), PassProcessor(),
                                     CreateAndPassSyncErrorFactory());
 
   // Process different types of changes, with conflicts. Note that all this data
   // has an older timestamp, so the local data will win in these scenarios.
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://new.com", "aaa",
                             10)));
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_UPDATE,
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key1",
                             10)));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   // Add one, update one, so we're up to 4.
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   // Local data wins twice so two updates are pushed up to Sync.
   EXPECT_EQ(2U, processor()->change_list_size());
 
   // aaa conflicts with key2 and loses, forcing it's keyword to update.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("aaa"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("aaa"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("new.com")));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("key2"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key2")));
   // key1 update conflicts with key3 and loses, forcing key1's keyword to
   // update.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("key1"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3.com")));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("key3"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3")));
 
   ASSERT_TRUE(processor()->contains_guid("aaa"));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE,
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             processor()->change_for_guid("aaa").change_type());
   ASSERT_TRUE(processor()->contains_guid("key1"));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE,
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             processor()->change_for_guid("key1").change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, RemoveUpdatedURLOnConflict) {
   // Updating a local replaceable URL to have the same keyword as a local
   // non-replaceable URL should result in the former being removed from the
   // model entirely.
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("sync"),
       "http://sync.com", "sync", 100, true));
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   TemplateURL* new_turl =
       CreateTestTemplateURL(ASCIIToUTF16("local"), "http://local.com", "local");
   model()->Add(new_turl);
 
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_UPDATE,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("local"), "http://sync.com", "sync",
                             110, true)));
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   EXPECT_EQ(1U, model()->GetTemplateURLs().size());
   EXPECT_EQ("local",
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("local"))->sync_guid());
   EXPECT_EQ(1U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("sync"));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE,
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
             processor()->change_for_guid("sync").change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessTemplateURLChange) {
   // Ensure that ProcessTemplateURLChange is called and pushes the correct
   // changes to Sync whenever local changes are made to TemplateURLs.
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                     CreateInitialSyncData(), PassProcessor(),
                                     CreateAndPassSyncErrorFactory());
 
   // Add a new search engine.
   TemplateURL* new_turl =
       CreateTestTemplateURL(ASCIIToUTF16("baidu"), "http://baidu.cn", "new");
   model()->Add(new_turl);
   EXPECT_EQ(1U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("new"));
-  csync::SyncChange change = processor()->change_for_guid("new");
-  EXPECT_EQ(csync::SyncChange::ACTION_ADD, change.change_type());
+  syncer::SyncChange change = processor()->change_for_guid("new");
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change.change_type());
   EXPECT_EQ("baidu", GetKeyword(change.sync_data()));
   EXPECT_EQ("http://baidu.cn", GetURL(change.sync_data()));
 
   // Change a keyword.
   TemplateURL* existing_turl = model()->GetTemplateURLForGUID("key1");
   model()->ResetTemplateURL(existing_turl, existing_turl->short_name(),
                             ASCIIToUTF16("k"), existing_turl->url());
   EXPECT_EQ(1U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("key1"));
   change = processor()->change_for_guid("key1");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, change.change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
   EXPECT_EQ("k", GetKeyword(change.sync_data()));
 
   // Remove an existing search engine.
   existing_turl = model()->GetTemplateURLForGUID("key2");
   model()->Remove(existing_turl);
   EXPECT_EQ(1U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("key2"));
   change = processor()->change_for_guid("key2");
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, change.change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change.change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithLocalExtensions) {
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                     CreateInitialSyncData(), PassProcessor(),
                                     CreateAndPassSyncErrorFactory());
 
   // Add some extension keywords locally.  These shouldn't be synced.
   TemplateURL* extension1 = CreateTestTemplateURL(ASCIIToUTF16("keyword1"),
       std::string(chrome::kExtensionScheme) + "://extension1");
   model()->Add(extension1);
   TemplateURL* extension2 = CreateTestTemplateURL(ASCIIToUTF16("keyword2"),
       std::string(chrome::kExtensionScheme) + "://extension2");
   model()->Add(extension2);
   EXPECT_EQ(0U, processor()->change_list_size());
 
   // Create some sync changes that will conflict with the extension keywords.
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
     CreateTestTemplateURL(ASCIIToUTF16("keyword1"), "http://aaa.com",
                           std::string(), 100, true)));
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
     CreateTestTemplateURL(ASCIIToUTF16("keyword2"), "http://bbb.com")));
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   // The synced keywords should be added unchanged, and the result of
   // GetTemplateURLForKeyword() for each keyword should depend on whether the
   // synced keyword is replaceable or not.
   EXPECT_EQ(extension1,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1")));
   EXPECT_FALSE(model()->GetTemplateURLForHost("aaa.com") == NULL);
   TemplateURL* url_for_keyword2 =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2"));
   EXPECT_NE(extension2, url_for_keyword2);
   EXPECT_EQ("http://bbb.com", url_for_keyword2->url());
   // Note that extensions don't use host-based keywords, so we can't check that
   // |extension2| is still in the model using GetTemplateURLForHost(); and we
   // have to create a full-fledged Extension to use
   // GetTemplateURLForExtension(), which is annoying, so just grab all the URLs
   // from the model and search for |extension2| within them.
   TemplateURLService::TemplateURLVector template_urls(
       model()->GetTemplateURLs());
   EXPECT_FALSE(std::find(template_urls.begin(), template_urls.end(),
                          extension2) == template_urls.end());
 }
 
 TEST_F(TemplateURLServiceSyncTest, AutogeneratedKeywordMigrated) {
   // Create a couple of sync entries with autogenerated keywords.
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   scoped_ptr<TemplateURL> turl(
       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1"));
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "{google:baseURL}search?q={searchTerms}", "key2"));
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
 
   // Now try to sync the data locally.
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Both entries should have been added, with explicit keywords.
   TemplateURL* key1 = model()->GetTemplateURLForHost("key1.com");
   ASSERT_FALSE(key1 == NULL);
   EXPECT_EQ(ASCIIToUTF16("key1.com"), key1->keyword());
   std::string google_hostname(
       GURL(UIThreadSearchTermsData(profile_a()).GoogleBaseURLValue()).host());
   TemplateURL* key2 = model()->GetTemplateURLForHost(google_hostname);
   ASSERT_FALSE(key2 == NULL);
   string16 google_keyword(net::StripWWW(ASCIIToUTF16(google_hostname)));
   EXPECT_EQ(google_keyword, key2->keyword());
 
   // We should also have gotten some corresponding UPDATEs pushed upstream.
   EXPECT_GE(processor()->change_list_size(), 2U);
   ASSERT_TRUE(processor()->contains_guid("key1"));
-  csync::SyncChange key1_change = processor()->change_for_guid("key1");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, key1_change.change_type());
+  syncer::SyncChange key1_change = processor()->change_for_guid("key1");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key1_change.change_type());
   EXPECT_EQ("key1.com", GetKeyword(key1_change.sync_data()));
   ASSERT_TRUE(processor()->contains_guid("key2"));
-  csync::SyncChange key2_change = processor()->change_for_guid("key2");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, key2_change.change_type());
+  syncer::SyncChange key2_change = processor()->change_for_guid("key2");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key2_change.change_type());
   EXPECT_EQ(google_keyword, UTF8ToUTF16(GetKeyword(key2_change.sync_data())));
 }
 
 TEST_F(TemplateURLServiceSyncTest, AutogeneratedKeywordConflicts) {
   // Sync brings in some autogenerated keywords, but the generated keywords we
   // try to create conflict with ones in the model.
   string16 google_keyword(net::StripWWW(ASCIIToUTF16(GURL(
       UIThreadSearchTermsData(profile_a()).GoogleBaseURLValue()).host())));
   TemplateURL* google = CreateTestTemplateURL(google_keyword,
       "{google:baseURL}1/search?q={searchTerms}");
   model()->Add(google);
   TemplateURL* other =
       CreateTestTemplateURL(ASCIIToUTF16("other.com"), "http://other.com/foo");
   model()->Add(other);
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("sync1"),
       "{google:baseURL}2/search?q={searchTerms}", "sync1", 50));
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("sync2"),
       "http://other.com/search?q={searchTerms}", "sync2", 150));
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // In this case, the conflicts should be handled just like any other keyword
   // conflicts -- the later-modified TemplateURL is assumed to be authoritative.
   EXPECT_EQ(google_keyword, google->keyword());
   EXPECT_EQ(google_keyword + ASCIIToUTF16("_"),
             model()->GetTemplateURLForGUID("sync1")->keyword());
   EXPECT_EQ(ASCIIToUTF16("other.com_"), other->keyword());
   EXPECT_EQ(ASCIIToUTF16("other.com"),
             model()->GetTemplateURLForGUID("sync2")->keyword());
 
   // Both synced URLs should have associated UPDATEs, since both needed their
   // keywords to be generated (and sync1 needed conflict resolution as well).
   EXPECT_GE(processor()->change_list_size(), 2U);
   ASSERT_TRUE(processor()->contains_guid("sync1"));
-  csync::SyncChange sync1_change = processor()->change_for_guid("sync1");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, sync1_change.change_type());
+  syncer::SyncChange sync1_change = processor()->change_for_guid("sync1");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, sync1_change.change_type());
   EXPECT_EQ(google_keyword + ASCIIToUTF16("_"),
             UTF8ToUTF16(GetKeyword(sync1_change.sync_data())));
   ASSERT_TRUE(processor()->contains_guid("sync2"));
-  csync::SyncChange sync2_change = processor()->change_for_guid("sync2");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, sync2_change.change_type());
+  syncer::SyncChange sync2_change = processor()->change_for_guid("sync2");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, sync2_change.change_type());
   EXPECT_EQ("other.com", GetKeyword(sync2_change.sync_data()));
 }
 
 TEST_F(TemplateURLServiceSyncTest, TwoAutogeneratedKeywordsUsingGoogleBaseURL) {
   // Sync brings in two autogenerated keywords and both use Google base URLs.
   // We make the first older so that it will get renamed once before the second
   // and then again once after (when we resolve conflicts for the second).
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "{google:baseURL}1/search?q={searchTerms}", "key1", 50));
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "{google:baseURL}2/search?q={searchTerms}", "key2"));
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // We should still have coalesced the updates to one each.
   string16 google_keyword(net::StripWWW(ASCIIToUTF16(GURL(
       UIThreadSearchTermsData(profile_a()).GoogleBaseURLValue()).host())));
   TemplateURL* keyword1 =
       model()->GetTemplateURLForKeyword(google_keyword + ASCIIToUTF16("_"));
   ASSERT_FALSE(keyword1 == NULL);
   EXPECT_EQ("key1", keyword1->sync_guid());
   TemplateURL* keyword2 = model()->GetTemplateURLForKeyword(google_keyword);
   ASSERT_FALSE(keyword2 == NULL);
   EXPECT_EQ("key2", keyword2->sync_guid());
   EXPECT_GE(processor()->change_list_size(), 2U);
   ASSERT_TRUE(processor()->contains_guid("key1"));
-  csync::SyncChange key1_change = processor()->change_for_guid("key1");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, key1_change.change_type());
+  syncer::SyncChange key1_change = processor()->change_for_guid("key1");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key1_change.change_type());
   EXPECT_EQ(keyword1->keyword(),
             UTF8ToUTF16(GetKeyword(key1_change.sync_data())));
   ASSERT_TRUE(processor()->contains_guid("key2"));
-  csync::SyncChange key2_change = processor()->change_for_guid("key2");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, key2_change.change_type());
+  syncer::SyncChange key2_change = processor()->change_for_guid("key2");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key2_change.change_type());
   EXPECT_EQ(keyword2->keyword(),
             UTF8ToUTF16(GetKeyword(key2_change.sync_data())));
 }
 
 TEST_F(TemplateURLServiceSyncTest, DuplicateEncodingsRemoved) {
   // Create a sync entry with duplicate encodings.
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
 
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("test");
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://test/%s");
   data.input_encodings.push_back("UTF-8");
   data.input_encodings.push_back("UTF-8");
   data.input_encodings.push_back("UTF-16");
   data.input_encodings.push_back("UTF-8");
   data.input_encodings.push_back("Big5");
@@ skipping 13 matching lines @@
 
   // The entry should have been added, with duplicate encodings removed.
   TemplateURL* keyword =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_FALSE(keyword == NULL);
   EXPECT_EQ(4U, keyword->input_encodings().size());
 
   // We should also have gotten a corresponding UPDATE pushed upstream.
   EXPECT_GE(processor()->change_list_size(), 1U);
   ASSERT_TRUE(processor()->contains_guid("keyword"));
-  csync::SyncChange keyword_change = processor()->change_for_guid("keyword");
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, keyword_change.change_type());
+  syncer::SyncChange keyword_change = processor()->change_for_guid("keyword");
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, keyword_change.change_type());
   EXPECT_EQ("UTF-8;UTF-16;Big5;Windows-1252", keyword_change.sync_data().
       GetSpecifics().search_engine().input_encodings());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeTwoClientsBasic) {
   // Start off B with some empty data.
   model_b()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                       CreateInitialSyncData(), PassProcessor(),
                                       CreateAndPassSyncErrorFactory());
 
   // Merge A and B. All of B's data should transfer over to A, which initially
   // has no data.
   scoped_ptr<SyncChangeProcessorDelegate> delegate_b(
       new SyncChangeProcessorDelegate(model_b()));
   model_a()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
       model_b()->GetAllSyncData(syncable::SEARCH_ENGINES),
-      delegate_b.PassAs<csync::SyncChangeProcessor>(),
+      delegate_b.PassAs<syncer::SyncChangeProcessor>(),
       CreateAndPassSyncErrorFactory());
 
   // They should be consistent.
   AssertEquals(model_a()->GetAllSyncData(syncable::SEARCH_ENGINES),
                model_b()->GetAllSyncData(syncable::SEARCH_ENGINES));
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeTwoClientsDupesAndConflicts) {
   // Start off B with some empty data.
   model_b()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
                                       CreateInitialSyncData(), PassProcessor(),
                                       CreateAndPassSyncErrorFactory());
 
   // Set up A so we have some interesting duplicates and conflicts.
   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key4"), "http://key4.com",
                                        "key4"));  // Added
   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com",
                                        "key2"));  // Merge - Copy of key2.
   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com",
                                        "key5", 10));  // Merge - Dupe of key3.
   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key6.com",
                                        "key6", 10));  // Conflict with key1
 
   // Merge A and B.
   scoped_ptr<SyncChangeProcessorDelegate> delegate_b(
       new SyncChangeProcessorDelegate(model_b()));
   model_a()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
       model_b()->GetAllSyncData(syncable::SEARCH_ENGINES),
-      delegate_b.PassAs<csync::SyncChangeProcessor>(),
+      delegate_b.PassAs<syncer::SyncChangeProcessor>(),
       CreateAndPassSyncErrorFactory());
 
   // They should be consistent.
   AssertEquals(model_a()->GetAllSyncData(syncable::SEARCH_ENGINES),
                model_b()->GetAllSyncData(syncable::SEARCH_ENGINES));
 }
 
 TEST_F(TemplateURLServiceSyncTest, StopSyncing) {
-  csync::SyncError error =
+  syncer::SyncError error =
       model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
       CreateInitialSyncData(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
   ASSERT_FALSE(error.IsSet());
   model()->StopSyncing(syncable::SEARCH_ENGINES);
 
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_UPDATE,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
                             "key2")));
   error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(error.IsSet());
 
   // Ensure that the sync changes were not accepted.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("newkeyword")));
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncErrorOnInitialSync) {
   processor()->set_erroneous(true);
-  csync::SyncError error =
+  syncer::SyncError error =
       model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
       CreateInitialSyncData(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
   EXPECT_TRUE(error.IsSet());
 
   // Ensure that if the initial merge was erroneous, then subsequence attempts
   // to push data into the local model are rejected, since the model was never
   // successfully associated with Sync in the first place.
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_UPDATE,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
                             "key2")));
   processor()->set_erroneous(false);
   error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(error.IsSet());
 
   // Ensure that the sync changes were not accepted.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("newkeyword")));
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncErrorOnLaterSync) {
   // Ensure that if the SyncProcessor succeeds in the initial merge, but fails
   // in future ProcessSyncChanges, we still return an error.
-  csync::SyncError error =
+  syncer::SyncError error =
       model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
       CreateInitialSyncData(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
   ASSERT_FALSE(error.IsSet());
 
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_UPDATE,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
                             "key2")));
   processor()->set_erroneous(true);
   error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(error.IsSet());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeTwiceWithSameSyncData) {
   // Ensure that a second merge with the same data as the first does not
   // actually update the local data.
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   initial_data.push_back(CreateInitialSyncData()[0]);
 
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
                                      "key1", 10));  // earlier
 
-  csync::SyncError error =
+  syncer::SyncError error =
       model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
       initial_data, PassProcessor(), CreateAndPassSyncErrorFactory());
   ASSERT_FALSE(error.IsSet());
 
   // We should have updated the original TemplateURL with Sync's version.
   // Keep a copy of it so we can compare it after we re-merge.
   TemplateURL* key1_url = model()->GetTemplateURLForGUID("key1");
   ASSERT_TRUE(key1_url);
   scoped_ptr<TemplateURL> updated_turl(new TemplateURL(key1_url->profile(),
                                                        key1_url->data()));
@@ skipping 18 matching lines @@
       initial_data, PassProcessor(), CreateAndPassSyncErrorFactory());
   ASSERT_FALSE(error.IsSet());
 
   // Check that the TemplateURL was not modified.
   const TemplateURL* reupdated_turl = model()->GetTemplateURLForGUID("key1");
   ASSERT_TRUE(reupdated_turl);
   AssertEquals(*updated_turl, *reupdated_turl);
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultGUIDArrivesFirst) {
-  csync::SyncDataList initial_data = CreateInitialSyncData();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
   // The default search provider should support replacement.
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "http://key2.com/{searchTerms}", "key2", 90));
   initial_data[1] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
   model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key2"));
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Change kSyncedDefaultSearchProviderGUID to a GUID that does not exist in
   // the model yet. Ensure that the default has not changed in any way.
   profile_a()->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, "newdefault");
 
   ASSERT_EQ(default_search, model()->GetDefaultSearchProvider());
 
   // Bring in a random new search engine with a different GUID. Ensure that
   // it doesn't change the default.
-  csync::SyncChangeList changes1;
-  changes1.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes1;
+  changes1.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("random"), "http://random.com",
                             "random")));
   model()->ProcessSyncChanges(FROM_HERE, changes1);
 
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   ASSERT_EQ(default_search, model()->GetDefaultSearchProvider());
 
   // Finally, bring in the expected entry with the right GUID. Ensure that
   // the default has changed to the new search engine.
-  csync::SyncChangeList changes2;
-  changes2.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes2;
+  changes2.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("new"), "http://new.com/{searchTerms}",
                             "newdefault")));
   model()->ProcessSyncChanges(FROM_HERE, changes2);
 
   EXPECT_EQ(5U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   ASSERT_NE(default_search, model()->GetDefaultSearchProvider());
   ASSERT_EQ("newdefault", model()->GetDefaultSearchProvider()->sync_guid());
 }
 
 TEST_F(TemplateURLServiceSyncTest, DefaultGuidDeletedAndReplaced) {
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   // The default search provider should support replacement.
   scoped_ptr<TemplateURL> turl1(CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com/{searchTerms}", "key1", 90));
   // Create a second default search provider for the
   // FindNewDefaultSearchProvider method to find.
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("unittest");
   data.SetKeyword(ASCIIToUTF16("key2"));
   data.SetURL("http://key2.com/{searchTerms}");
   data.favicon_url = GURL("http://favicon.url");
@@ skipping 13 matching lines @@
       PassProcessor(), CreateAndPassSyncErrorFactory());
   model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key1"));
   ASSERT_EQ("key1", model()->GetDefaultSearchProvider()->sync_guid());
 
   EXPECT_EQ(2U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Delete the old default. This will change the default to the next available
   // (turl2), but should not affect the synced preference.
-  csync::SyncChangeList changes1;
-  changes1.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_DELETE,
+  syncer::SyncChangeList changes1;
+  changes1.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_DELETE,
                                           turl1.release()));
   model()->ProcessSyncChanges(FROM_HERE, changes1);
 
   EXPECT_EQ(1U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_EQ("key2", model()->GetDefaultSearchProvider()->sync_guid());
   EXPECT_EQ("key1", profile_a()->GetTestingPrefService()->GetString(
       prefs::kSyncedDefaultSearchProviderGUID));
 
   // Change kSyncedDefaultSearchProviderGUID to a GUID that does not exist in
   // the model yet. Ensure that the default has not changed in any way.
   profile_a()->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, "newdefault");
 
   ASSERT_EQ("key2", model()->GetDefaultSearchProvider()->sync_guid());
   EXPECT_EQ("newdefault", profile_a()->GetTestingPrefService()->GetString(
       prefs::kSyncedDefaultSearchProviderGUID));
 
   // Finally, bring in the expected entry with the right GUID. Ensure that
   // the default has changed to the new search engine.
-  csync::SyncChangeList changes2;
-  changes2.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes2;
+  changes2.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("new"), "http://new.com/{searchTerms}",
                             "newdefault")));
   model()->ProcessSyncChanges(FROM_HERE, changes2);
 
   EXPECT_EQ(2U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_EQ("newdefault", model()->GetDefaultSearchProvider()->sync_guid());
   EXPECT_EQ("newdefault", profile_a()->GetTestingPrefService()->GetString(
       prefs::kSyncedDefaultSearchProviderGUID));
 }
 
@@ skipping 12 matching lines @@
   // Set kSyncedDefaultSearchProviderGUID to something that is not yet in
   // the model but is expected in the initial sync. Ensure that this doesn't
   // change our default since we're not quite syncing yet.
   profile_a()->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, "key2");
 
   EXPECT_EQ(default_search, model()->GetDefaultSearchProvider());
 
   // Now sync the initial data, which will include the search engine entry
   // destined to become the new default.
-  csync::SyncDataList initial_data = CreateInitialSyncData();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
   // The default search provider should support replacement.
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "http://key2.com/{searchTerms}", "key2", 90));
   initial_data[1] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Ensure that the new default has been set.
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
@@ skipping 13 matching lines @@
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Set kSyncedDefaultSearchProviderGUID to the current default.
   profile_a()->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, kGUID);
 
   EXPECT_EQ(default_search, model()->GetDefaultSearchProvider());
 
   // Now sync the initial data.
-  csync::SyncDataList initial_data = CreateInitialSyncData();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Ensure that the new entries were added and the default has not changed.
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   ASSERT_EQ(default_search, model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncWithManagedDefaultSearch) {
   // First start off with a few entries and make sure we can set an unmanaged
   // default search provider.
-  csync::SyncDataList initial_data = CreateInitialSyncData();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
   model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key2"));
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   ASSERT_FALSE(model()->is_default_search_managed());
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 
   // Change the default search provider to a managed one.
   const char kName[] = "manageddefault";
   const char kSearchURL[] = "http://manageddefault.com/search?t={searchTerms}";
   const char kIconURL[] = "http://manageddefault.com/icon.jpg";
   const char kEncodings[] = "UTF-16;UTF-32";
   test_util_a_.SetManagedDefaultSearchPreferences(true, kName, kName,
       kSearchURL, std::string(), kIconURL, kEncodings);
   const TemplateURL* dsp_turl = model()->GetDefaultSearchProvider();
 
   EXPECT_TRUE(model()->is_default_search_managed());
 
   // Add a new entry from Sync. It should still sync in despite the default
   // being managed.
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_ADD,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"),
                             "http://new.com/{searchTerms}",
                             "newdefault")));
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
 
   // Change kSyncedDefaultSearchProviderGUID to point to the new entry and
   // ensure that the DSP remains managed.
   profile_a()->GetTestingPrefService()->SetString(
@@ skipping 13 matching lines @@
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncMergeDeletesDefault) {
   // If the value from Sync is a duplicate of the local default and is newer, it
   // should safely replace the local value and set as the new default.
   TemplateURL* default_turl = CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com/{searchTerms}", "whateverguid", 10);
   model()->Add(default_turl);
   model()->SetDefaultSearchProvider(default_turl);
 
-  csync::SyncDataList initial_data = CreateInitialSyncData();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
   // The key1 entry should be a duplicate of the default.
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com/{searchTerms}", "key1", 90));
   initial_data[0] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_FALSE(model()->GetTemplateURLForGUID("whateverguid"));
   EXPECT_EQ(model()->GetDefaultSearchProvider(),
             model()->GetTemplateURLForGUID("key1"));
 }
 
 TEST_F(TemplateURLServiceSyncTest, LocalDefaultWinsConflict) {
   // We expect that the local default always wins keyword conflict resolution.
   const string16 keyword(ASCIIToUTF16("key1"));
   TemplateURL* default_turl = CreateTestTemplateURL(keyword,
       "http://whatever.com/{searchTerms}", "whateverguid", 10);
   model()->Add(default_turl);
   model()->SetDefaultSearchProvider(default_turl);
 
-  csync::SyncDataList initial_data = CreateInitialSyncData();
+  syncer::SyncDataList initial_data = CreateInitialSyncData();
   // The key1 entry should be different from the default but conflict in the
   // keyword.
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(keyword,
       "http://key1.com/{searchTerms}", "key1", 90));
   initial_data[0] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // The conflicting TemplateURL should be added, but it should have lost
   // conflict resolution against the default.
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   const TemplateURL* winner = model()->GetTemplateURLForGUID("whateverguid");
   ASSERT_TRUE(winner);
   EXPECT_EQ(model()->GetDefaultSearchProvider(), winner);
   EXPECT_EQ(keyword, winner->keyword());
   const TemplateURL* loser = model()->GetTemplateURLForGUID("key1");
   ASSERT_TRUE(loser);
   EXPECT_EQ(ASCIIToUTF16("key1.com"), loser->keyword());
 }
 
 TEST_F(TemplateURLServiceSyncTest, DeleteBogusData) {
   // Create a couple of bogus entries to sync.
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   scoped_ptr<TemplateURL> turl(
       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1"));
   initial_data.push_back(
       CreateCustomSyncData(*turl, false, std::string(), turl->sync_guid()));
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
   initial_data.push_back(
       CreateCustomSyncData(*turl, false, turl->url(), std::string()));
 
   // Now try to sync the data locally.
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // Nothing should have been added, and both bogus entries should be marked for
   // deletion.
   EXPECT_EQ(0U, model()->GetTemplateURLs().size());
   EXPECT_EQ(2U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("key1"));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE,
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
             processor()->change_for_guid("key1").change_type());
   ASSERT_TRUE(processor()->contains_guid(std::string()));
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE,
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
             processor()->change_for_guid(std::string()).change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, PreSyncDeletes) {
   model()->pre_sync_deletes_.insert("key1");
   model()->pre_sync_deletes_.insert("key2");
   model()->pre_sync_deletes_.insert("aaa");
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("whatever"),
       "http://key1.com", "bbb"));
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
       CreateInitialSyncData(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
   // We expect the model to have GUIDs {bbb, key3} after our initial merge.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("bbb"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
-  csync::SyncChange change = processor()->change_for_guid("key1");
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, change.change_type());
+  syncer::SyncChange change = processor()->change_for_guid("key1");
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change.change_type());
   change = processor()->change_for_guid("key2");
-  EXPECT_EQ(csync::SyncChange::ACTION_DELETE, change.change_type());
+  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change.change_type());
   // "aaa" should have been pruned out on account of not being from Sync.
   EXPECT_FALSE(processor()->contains_guid("aaa"));
   // The set of pre-sync deletes should be cleared so they're not reused if
   // MergeDataAndStartSyncing gets called again.
   EXPECT_TRUE(model()->pre_sync_deletes_.empty());
 }
 
 TEST_F(TemplateURLServiceSyncTest, PreSyncUpdates) {
   const char* kNewKeyword = "somethingnew";
   // Fetch the prepopulate search engines so we know what they are.
@@ skipping 27 matching lines @@
       ASCIIToUTF16(kNewKeyword));
   base::Time new_timestamp = added_turl->last_modified();
   EXPECT_GE(new_timestamp, pre_merge_time);
   ASSERT_TRUE(added_turl);
   std::string sync_guid = added_turl->sync_guid();
 
   // Bring down a copy of the prepopulate engine from Sync with the old values,
   // including the old timestamp and the same GUID. Ensure that it loses
   // conflict resolution against the local value, and an update is sent to the
   // server. The new timestamp should be preserved.
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   data_copy.SetKeyword(original_keyword);
   data_copy.sync_guid = sync_guid;
   scoped_ptr<TemplateURL> sync_turl(
       new TemplateURL(prepop_turls[0]->profile(), data_copy));
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
       initial_data, PassProcessor(), CreateAndPassSyncErrorFactory());
 
   ASSERT_EQ(added_turl, model()->GetTemplateURLForKeyword(
       ASCIIToUTF16(kNewKeyword)));
   EXPECT_EQ(new_timestamp, added_turl->last_modified());
-  csync::SyncChange change = processor()->change_for_guid(sync_guid);
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, change.change_type());
+  syncer::SyncChange change = processor()->change_for_guid(sync_guid);
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
   EXPECT_EQ(kNewKeyword,
             change.sync_data().GetSpecifics().search_engine().keyword());
   EXPECT_EQ(new_timestamp, base::Time::FromInternalValue(
       change.sync_data().GetSpecifics().search_engine().last_modified()));
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncBaseURLs) {
   // Verify that bringing in a remote TemplateURL that uses Google base URLs
   // causes it to get a local keyword that matches the local base URL.
   test_util_a_.SetGoogleBaseURL(GURL("http://google.com/"));
-  csync::SyncDataList initial_data;
+  syncer::SyncDataList initial_data;
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(
       ASCIIToUTF16("google.co.uk"), "{google:baseURL}search?q={searchTerms}",
       "guid"));
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
   TemplateURL* synced_turl = model()->GetTemplateURLForGUID("guid");
   ASSERT_TRUE(synced_turl);
   EXPECT_EQ(ASCIIToUTF16("google.com"), synced_turl->keyword());
   EXPECT_EQ(0U, processor()->change_list_size());
 
   // Remote updates to this URL's keyword should be silently ignored.
-  csync::SyncChangeList changes;
-  changes.push_back(CreateTestSyncChange(csync::SyncChange::ACTION_UPDATE,
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("google.de"),
           "{google:baseURL}search?q={searchTerms}", "guid")));
   model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_EQ(ASCIIToUTF16("google.com"), synced_turl->keyword());
   EXPECT_EQ(0U, processor()->change_list_size());
 
   // A local change to the Google base URL should update the keyword and
   // generate a sync change.
   test_util_a_.SetGoogleBaseURL(GURL("http://google.co.in/"));
   EXPECT_EQ(ASCIIToUTF16("google.co.in"), synced_turl->keyword());
   EXPECT_EQ(1U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("guid"));
-  csync::SyncChange change(processor()->change_for_guid("guid"));
-  EXPECT_EQ(csync::SyncChange::ACTION_UPDATE, change.change_type());
+  syncer::SyncChange change(processor()->change_for_guid("guid"));
+  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
   EXPECT_EQ("google.co.in", GetKeyword(change.sync_data()));
 }