[Sync] Rename csync namespace to syncer

chrome/browser/search_engines/template_url_service.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 "chrome/browser/search_engines/template_url_service.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/guid.h"
@@ skipping 92 matching lines @@
 // to changes after it in |change_list|.
 // The criteria is:
 //  1) It is an ACTION_UPDATE or ACTION_DELETE and the sync_guid associated
 //     with it is NOT found in |sync_data|. We can only update and remove
 //     entries that were originally from the Sync server.
 //  2) It is an ACTION_ADD and the sync_guid associated with it is found in
 //     |sync_data|. We cannot re-add entries that Sync already knew about.
 //  3) There is an update after an update for the same GUID. We prune earlier
 //     ones just to save bandwidth (Sync would normally coalesce them).
 bool ShouldRemoveSyncChange(size_t index,
-                            csync::SyncChangeList* change_list,
+                            syncer::SyncChangeList* change_list,
                             const SyncDataMap* sync_data) {
   DCHECK(index < change_list->size());
-  const csync::SyncChange& change_i = (*change_list)[index];
+  const syncer::SyncChange& change_i = (*change_list)[index];
   const std::string guid = change_i.sync_data().GetSpecifics()
       .search_engine().sync_guid();
-  csync::SyncChange::SyncChangeType type = change_i.change_type();
-  if ((type == csync::SyncChange::ACTION_UPDATE ||
-       type == csync::SyncChange::ACTION_DELETE) &&
+  syncer::SyncChange::SyncChangeType type = change_i.change_type();
+  if ((type == syncer::SyncChange::ACTION_UPDATE ||
+       type == syncer::SyncChange::ACTION_DELETE) &&
        sync_data->find(guid) == sync_data->end())
     return true;
-  if (type == csync::SyncChange::ACTION_ADD &&
+  if (type == syncer::SyncChange::ACTION_ADD &&
       sync_data->find(guid) != sync_data->end())
     return true;
-  if (type == csync::SyncChange::ACTION_UPDATE) {
+  if (type == syncer::SyncChange::ACTION_UPDATE) {
     for (size_t j = index + 1; j < change_list->size(); j++) {
-      const csync::SyncChange& change_j = (*change_list)[j];
-      if ((csync::SyncChange::ACTION_UPDATE == change_j.change_type()) &&
+      const syncer::SyncChange& change_j = (*change_list)[j];
+      if ((syncer::SyncChange::ACTION_UPDATE == change_j.change_type()) &&
           (change_j.sync_data().GetSpecifics().search_engine().sync_guid() ==
               guid))
         return true;
     }
   }
   return false;
 }
 
 // Remove SyncChanges that should not be sent to the server from |change_list|.
-// This is done to eliminate incorrect csync::SyncChanges added by the merge and
+// This is done to eliminate incorrect SyncChanges added by the merge and
 // conflict resolution logic when it is unsure of whether or not an entry is new
 // from Sync or originally from the local model. This also removes changes that
 // would be otherwise be coalesced by Sync in order to save bandwidth.
 void PruneSyncChanges(const SyncDataMap* sync_data,
-                      csync::SyncChangeList* change_list) {
+                      syncer::SyncChangeList* change_list) {
   for (size_t i = 0; i < change_list->size(); ) {
     if (ShouldRemoveSyncChange(i, change_list, sync_data))
       change_list->erase(change_list->begin() + i);
     else
       ++i;
   }
 }
 
 // Helper class that reports a specific string as the Google base URL.  We use
 // this so that code can calculate a TemplateURL's previous search URL after a
@@ skipping 700 matching lines @@
       // flag to indicate that we waiting on the search engine entry to come
       // in through Sync.
       pending_synced_default_search_ = true;
     }
     UpdateDefaultSearch();
   } else {
     NOTREACHED();
   }
 }
 
-csync::SyncDataList TemplateURLService::GetAllSyncData(
+syncer::SyncDataList TemplateURLService::GetAllSyncData(
     syncable::ModelType type) const {
   DCHECK_EQ(syncable::SEARCH_ENGINES, type);
 
-  csync::SyncDataList current_data;
+  syncer::SyncDataList current_data;
   for (TemplateURLVector::const_iterator iter = template_urls_.begin();
       iter != template_urls_.end(); ++iter) {
     // We don't sync extension keywords.
     // TODO(mpcomplete): If we allow editing extension keywords, then those
     // should be persisted to disk and synced.
     if ((*iter)->IsExtensionKeyword())
       continue;
     // We don't sync keywords managed by policy.
     if ((*iter)->created_by_policy())
       continue;
     current_data.push_back(CreateSyncDataFromTemplateURL(**iter));
   }
 
   return current_data;
 }
 
-csync::SyncError TemplateURLService::ProcessSyncChanges(
+syncer::SyncError TemplateURLService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const csync::SyncChangeList& change_list) {
+    const syncer::SyncChangeList& change_list) {
   if (!models_associated_) {
-    csync::SyncError error(FROM_HERE, "Models not yet associated.",
+    syncer::SyncError error(FROM_HERE, "Models not yet associated.",
                     syncable::SEARCH_ENGINES);
     return error;
   }
   DCHECK(loaded_);
 
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
   // We've started syncing, so set our origin member to the base Sync value.
   // As we move through Sync Code, we may set this to increasingly specific
   // origins so we can tell what exactly caused a DSP change.
   AutoReset<DefaultSearchChangeOrigin> change_origin(&dsp_change_origin_,
       DSP_CHANGE_SYNC_UNINTENTIONAL);
 
-  csync::SyncChangeList new_changes;
-  csync::SyncError error;
-  for (csync::SyncChangeList::const_iterator iter = change_list.begin();
+  syncer::SyncChangeList new_changes;
+  syncer::SyncError error;
+  for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
       iter != change_list.end(); ++iter) {
     DCHECK_EQ(syncable::SEARCH_ENGINES, iter->sync_data().GetDataType());
 
     std::string guid =
         iter->sync_data().GetSpecifics().search_engine().sync_guid();
     TemplateURL* existing_turl = GetTemplateURLForGUID(guid);
     scoped_ptr<TemplateURL> turl(CreateTemplateURLFromTemplateURLAndSyncData(
         profile_, existing_turl, iter->sync_data(), &new_changes));
     if (!turl.get())
       continue;
 
     // Explicitly don't check for conflicts against extension keywords; in this
     // case the functions which modify the keyword map know how to handle the
     // conflicts.
     // TODO(mpcomplete): If we allow editing extension keywords, then those will
     // need to undergo conflict resolution.
     TemplateURL* existing_keyword_turl =
         FindNonExtensionTemplateURLForKeyword(turl->keyword());
-    if (iter->change_type() == csync::SyncChange::ACTION_DELETE) {
+    if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) {
       if (!existing_turl) {
         NOTREACHED() << "Unexpected sync change state.";
         error = sync_error_factory_->CreateAndUploadError(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_DELETE");
         LOG(ERROR) << "Trying to delete a non-existent TemplateURL.";
         continue;
       }
       bool delete_default = (existing_turl == GetDefaultSearchProvider());
 
       if (delete_default && is_default_search_managed_) {
         NOTREACHED() << "Tried to delete managed default search provider";
       } else {
         if (delete_default)
           default_search_provider_ = NULL;
 
         Remove(existing_turl);
 
         if (delete_default) {
           AutoReset<DefaultSearchChangeOrigin> change_origin(
               &dsp_change_origin_, DSP_CHANGE_SYNC_DELETE);
           SetDefaultSearchProvider(FindNewDefaultSearchProvider());
         }
       }
-    } else if (iter->change_type() == csync::SyncChange::ACTION_ADD) {
+    } else if (iter->change_type() == syncer::SyncChange::ACTION_ADD) {
       if (existing_turl) {
         NOTREACHED() << "Unexpected sync change state.";
         error = sync_error_factory_->CreateAndUploadError(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_ADD");
         LOG(ERROR) << "Trying to add an existing TemplateURL.";
         continue;
       }
       std::string guid = turl->sync_guid();
       if (!existing_keyword_turl || ResolveSyncKeywordConflict(turl.get(),
           existing_keyword_turl, &new_changes)) {
         // Force the local ID to kInvalidTemplateURLID so we can add it.
         TemplateURLData data(turl->data());
         data.id = kInvalidTemplateURLID;
         Add(new TemplateURL(profile_, data));
 
         // Possibly set the newly added |turl| as the default search provider.
         SetDefaultSearchProviderIfNewlySynced(guid);
       }
-    } else if (iter->change_type() == csync::SyncChange::ACTION_UPDATE) {
+    } else if (iter->change_type() == syncer::SyncChange::ACTION_UPDATE) {
       if (!existing_turl) {
         NOTREACHED() << "Unexpected sync change state.";
         error = sync_error_factory_->CreateAndUploadError(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType ACTION_UPDATE");
         LOG(ERROR) << "Trying to update a non-existent TemplateURL.";
         continue;
       }
       // Possibly resolve a keyword conflict if they have the same keywords but
       // are not the same entry.
@@ skipping 21 matching lines @@
   // If something went wrong, we want to prematurely exit to avoid pushing
   // inconsistent data to Sync. We return the last error we received.
   if (error.IsSet())
     return error;
 
   error = sync_processor_->ProcessSyncChanges(from_here, new_changes);
 
   return error;
 }
 
-csync::SyncError TemplateURLService::MergeDataAndStartSyncing(
+syncer::SyncError TemplateURLService::MergeDataAndStartSyncing(
     syncable::ModelType type,
-    const csync::SyncDataList& initial_sync_data,
-    scoped_ptr<csync::SyncChangeProcessor> sync_processor,
-    scoped_ptr<csync::SyncErrorFactory> sync_error_factory) {
+    const syncer::SyncDataList& initial_sync_data,
+    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
+    scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   DCHECK(loaded_);
   DCHECK_EQ(type, syncable::SEARCH_ENGINES);
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
   sync_processor_ = sync_processor.Pass();
   sync_error_factory_ = sync_error_factory.Pass();
 
   // We just started syncing, so set our wait-for-default flag if we are
   // expecting a default from Sync.
@@ skipping 10 matching lines @@
   // We do a lot of calls to Add/Remove/ResetTemplateURL here, so ensure we
   // don't step on our own toes.
   AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
   // We've started syncing, so set our origin member to the base Sync value.
   // As we move through Sync Code, we may set this to increasingly specific
   // origins so we can tell what exactly caused a DSP change.
   AutoReset<DefaultSearchChangeOrigin> change_origin(&dsp_change_origin_,
       DSP_CHANGE_SYNC_UNINTENTIONAL);
 
-  csync::SyncChangeList new_changes;
+  syncer::SyncChangeList new_changes;
 
-  // Build maps of our sync GUIDs to csync::SyncData.
+  // Build maps of our sync GUIDs to syncer::SyncData.
   SyncDataMap local_data_map = CreateGUIDToSyncDataMap(
       GetAllSyncData(syncable::SEARCH_ENGINES));
   SyncDataMap sync_data_map = CreateGUIDToSyncDataMap(initial_sync_data);
 
   for (SyncDataMap::const_iterator iter = sync_data_map.begin();
       iter != sync_data_map.end(); ++iter) {
     TemplateURL* local_turl = GetTemplateURLForGUID(iter->first);
     scoped_ptr<TemplateURL> sync_turl(
         CreateTemplateURLFromTemplateURLAndSyncData(profile_, local_turl,
             iter->second, &new_changes));
     if (!sync_turl.get())
       continue;
 
     if (pre_sync_deletes_.find(sync_turl->sync_guid()) !=
         pre_sync_deletes_.end()) {
       // This entry was deleted before the initial sync began (possibly through
       // preprocessing in TemplateURLService's loading code). Ignore it and send
       // an ACTION_DELETE up to the server.
-      new_changes.push_back(csync::SyncChange(csync::SyncChange::ACTION_DELETE,
-                                       iter->second));
+      new_changes.push_back(
+          syncer::SyncChange(syncer::SyncChange::ACTION_DELETE,
+                             iter->second));
       continue;
     }
 
     if (local_turl) {
       // This local search engine is already synced. If the timestamp differs
       // from Sync, we need to update locally or to the cloud. Note that if the
       // timestamps are equal, we touch neither.
       if (sync_turl->last_modified() > local_turl->last_modified()) {
         // We've received an update from Sync. We should replace all synced
         // fields in the local TemplateURL. Note that this includes the
         // TemplateURLID and the TemplateURL may have to be reparsed. This
         // also makes the local data's last_modified timestamp equal to Sync's,
         // avoiding an Update on the next MergeData call.
         UIThreadSearchTermsData search_terms_data(local_turl->profile());
         if (UpdateNoNotify(local_turl, *sync_turl, search_terms_data))
           NotifyObservers();
       } else if (sync_turl->last_modified() < local_turl->last_modified()) {
         // Otherwise, we know we have newer data, so update Sync with our
         // data fields.
         new_changes.push_back(
-            csync::SyncChange(csync::SyncChange::ACTION_UPDATE,
+            syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE,
             local_data_map[local_turl->sync_guid()]));
       }
       local_data_map.erase(iter->first);
     } else {
       // The search engine from the cloud has not been synced locally, but there
       // might be a local search engine that is a duplicate that needs to be
       // merged.
       TemplateURL* dupe_turl = FindDuplicateOfSyncTemplateURL(*sync_turl);
       if (dupe_turl) {
         // Merge duplicates and remove the processed local TURL from the map.
@@ skipping 22 matching lines @@
         }
       }
     }
   }
 
   // The remaining SyncData in local_data_map should be everything that needs to
   // be pushed as ADDs to sync.
   for (SyncDataMap::const_iterator iter = local_data_map.begin();
       iter != local_data_map.end(); ++iter) {
     new_changes.push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_ADD, iter->second));
+        syncer::SyncChange(syncer::SyncChange::ACTION_ADD, iter->second));
   }
 
   // Do some post-processing on the change list to ensure that we are sending
   // valid changes to sync_processor_.
   PruneSyncChanges(&sync_data_map, &new_changes);
 
-  csync::SyncError error =
+  syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
   if (error.IsSet())
     return error;
 
   // The ACTION_DELETEs from this set are processed. Empty it so we don't try to
   // reuse them on the next call to MergeDataAndStartSyncing.
   pre_sync_deletes_.clear();
 
   models_associated_ = true;
-  return csync::SyncError();
+  return syncer::SyncError();
 }
 
 void TemplateURLService::StopSyncing(syncable::ModelType type) {
   DCHECK_EQ(type, syncable::SEARCH_ENGINES);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
 }
 
 void TemplateURLService::ProcessTemplateURLChange(
     const TemplateURL* turl,
-    csync::SyncChange::SyncChangeType type) {
-  DCHECK_NE(type, csync::SyncChange::ACTION_INVALID);
+    syncer::SyncChange::SyncChangeType type) {
+  DCHECK_NE(type, syncer::SyncChange::ACTION_INVALID);
   DCHECK(turl);
 
   if (!models_associated_)
     return;  // Not syncing.
 
   if (processing_syncer_changes_)
     return;  // These are changes originating from us. Ignore.
 
   // Avoid syncing Extension keywords.
   // TODO(mpcomplete): If we allow editing extension keywords, then those should
   // be persisted to disk and synced.
   if (turl->IsExtensionKeyword())
     return;
 
   // Avoid syncing keywords managed by policy.
   if (turl->created_by_policy())
     return;
 
-  csync::SyncChangeList changes;
+  syncer::SyncChangeList changes;
 
-  csync::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
-  changes.push_back(csync::SyncChange(type, sync_data));
+  syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
+  changes.push_back(syncer::SyncChange(type, sync_data));
 
   sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 // static
-csync::SyncData TemplateURLService::CreateSyncDataFromTemplateURL(
+syncer::SyncData TemplateURLService::CreateSyncDataFromTemplateURL(
     const TemplateURL& turl) {
   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(UTF16ToUTF8(turl.keyword()));
   se_specifics->set_favicon_url(turl.favicon_url().spec());
   se_specifics->set_url(turl.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_instant_url(turl.instant_url());
   se_specifics->set_last_modified(turl.last_modified().ToInternalValue());
   se_specifics->set_sync_guid(turl.sync_guid());
-  return csync::SyncData::CreateLocalData(se_specifics->sync_guid(),
+  return syncer::SyncData::CreateLocalData(se_specifics->sync_guid(),
                                    se_specifics->keyword(),
                                    specifics);
 }
 
 // static
 TemplateURL* TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
     Profile* profile,
     TemplateURL* existing_turl,
-    const csync::SyncData& sync_data,
-    csync::SyncChangeList* change_list) {
+    const syncer::SyncData& sync_data,
+    syncer::SyncChangeList* change_list) {
   DCHECK(change_list);
 
   sync_pb::SearchEngineSpecifics specifics =
       sync_data.GetSpecifics().search_engine();
 
   // Past bugs might have caused either of these fields to be empty.  Just
   // delete this data off the server.
   if (specifics.url().empty() || specifics.sync_guid().empty()) {
     change_list->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_DELETE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_DELETE, sync_data));
     return NULL;
   }
 
   TemplateURLData data(existing_turl ?
       existing_turl->data() : TemplateURLData());
   data.short_name = UTF8ToUTF16(specifics.short_name());
   data.originating_url = GURL(specifics.originating_url());
   string16 keyword(UTF8ToUTF16(specifics.keyword()));
   // NOTE: Once this code has shipped in a couple of stable releases, we can
   // probably remove the migration portion, comment out the
@@ skipping 20 matching lines @@
   data.date_created = base::Time::FromInternalValue(specifics.date_created());
   data.last_modified = base::Time::FromInternalValue(specifics.last_modified());
   data.prepopulate_id = specifics.prepopulate_id();
   data.sync_guid = specifics.sync_guid();
 
   TemplateURL* turl = new TemplateURL(profile, data);
   DCHECK(!turl->IsExtensionKeyword());
   if (reset_keyword || deduped) {
     if (reset_keyword)
       turl->ResetKeywordIfNecessary(true);
-    csync::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
+    syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
     change_list->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_UPDATE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
   } else if (turl->IsGoogleSearchURLWithReplaceableKeyword()) {
     if (!existing_turl) {
       // We're adding a new TemplateURL that uses the Google base URL, so set
       // its keyword appropriately for the local environment.
       turl->ResetKeywordIfNecessary(false);
     } else if (existing_turl->IsGoogleSearchURLWithReplaceableKeyword()) {
       // Ignore keyword changes triggered by the Google base URL changing on
       // another client.  If the base URL changes in this client as well, we'll
       // pick that up separately at the appropriate time.  Otherwise, changing
       // the keyword here could result in having the wrong keyword for the local
       // environment.
       turl->data_.SetKeyword(existing_turl->keyword());
     }
   }
 
   return turl;
 }
 
 // static
 SyncDataMap TemplateURLService::CreateGUIDToSyncDataMap(
-    const csync::SyncDataList& sync_data) {
+    const syncer::SyncDataList& sync_data) {
   SyncDataMap data_map;
-  for (csync::SyncDataList::const_iterator i(sync_data.begin());
+  for (syncer::SyncDataList::const_iterator i(sync_data.begin());
        i != sync_data.end();
        ++i)
     data_map[i->GetSpecifics().search_engine().sync_guid()] = *i;
   return data_map;
 }
 
 void TemplateURLService::SetKeywordSearchTermsForURL(const TemplateURL* t_url,
                                                      const GURL& url,
                                                      const string16& term) {
   HistoryService* history = profile_  ?
@@ skipping 412 matching lines @@
       }
     }
   }
   if (!existing_turl->sync_guid().empty())
     guid_to_template_map_[existing_turl->sync_guid()] = existing_turl;
 
   if (service_.get())
     service_->UpdateKeyword(existing_turl->data());
 
   // Inform sync of the update.
-  ProcessTemplateURLChange(existing_turl, csync::SyncChange::ACTION_UPDATE);
+  ProcessTemplateURLChange(existing_turl, syncer::SyncChange::ACTION_UPDATE);
 
   if (default_search_provider_ == existing_turl) {
     bool success = SetDefaultSearchProviderNoNotify(existing_turl);
     DCHECK(success);
   }
   return true;
 }
 
 PrefService* TemplateURLService::GetPrefs() {
   return profile_ ? profile_->GetPrefs() : NULL;
@@ skipping 310 matching lines @@
       GetPrefs()->SetString(prefs::kSyncedDefaultSearchProviderGUID,
                             url->sync_guid());
     }
   }
 
   if (service_.get())
     service_->SetDefaultSearchProvider(url);
 
   // Inform sync the change to the show_in_default_list flag.
   if (url)
-    ProcessTemplateURLChange(url, csync::SyncChange::ACTION_UPDATE);
+    ProcessTemplateURLChange(url, syncer::SyncChange::ACTION_UPDATE);
   return true;
 }
 
 bool TemplateURLService::AddNoNotify(TemplateURL* template_url,
                                      bool newly_adding) {
   DCHECK(template_url);
 
   if (newly_adding) {
     DCHECK_EQ(kInvalidTemplateURLID, template_url->id());
     DCHECK(std::find(template_urls_.begin(), template_urls_.end(),
@@ skipping 28 matching lines @@
   if (newly_adding) {
     // Don't persist extension keywords to disk.  They'll get re-added on each
     // launch as the extensions are loaded.
     // TODO(mpcomplete): If we allow editing extension keywords, then those
     // should be persisted to disk and synced.
     if (service_.get() && !template_url->IsExtensionKeyword())
       service_->AddKeyword(template_url->data());
 
     // Inform sync of the addition. Note that this will assign a GUID to
     // template_url and add it to the guid_to_template_map_.
-    ProcessTemplateURLChange(template_url, csync::SyncChange::ACTION_ADD);
+    ProcessTemplateURLChange(template_url, syncer::SyncChange::ACTION_ADD);
   }
 
   return true;
 }
 
 void TemplateURLService::RemoveNoNotify(TemplateURL* template_url) {
   TemplateURLVector::iterator i =
       std::find(template_urls_.begin(), template_urls_.end(), template_url);
   if (i == template_urls_.end())
     return;
 
   if (template_url == default_search_provider_) {
     // Should never delete the default search provider.
     NOTREACHED();
     return;
   }
 
   RemoveFromMaps(template_url);
 
   // Remove it from the vector containing all TemplateURLs.
   template_urls_.erase(i);
 
   // Extension keywords are not persisted.
   // TODO(mpcomplete): If we allow editing extension keywords, then those should
   // be persisted to disk and synced.
   if (service_.get() && !template_url->IsExtensionKeyword())
     service_->RemoveKeyword(template_url->id());
 
   // Inform sync of the deletion.
-  ProcessTemplateURLChange(template_url, csync::SyncChange::ACTION_DELETE);
+  ProcessTemplateURLChange(template_url, syncer::SyncChange::ACTION_DELETE);
 
   if (profile_) {
     content::Source<Profile> source(profile_);
     TemplateURLID id = template_url->id();
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_TEMPLATE_URL_REMOVED,
         source,
         content::Details<TemplateURLID>(&id));
   }
 
@@ skipping 91 matching lines @@
   do {
     keyword_candidate.append(ASCIIToUTF16("_"));
   } while (GetTemplateURLForKeyword(keyword_candidate));
 
   return keyword_candidate;
 }
 
 bool TemplateURLService::ResolveSyncKeywordConflict(
     TemplateURL* sync_turl,
     TemplateURL* local_turl,
-    csync::SyncChangeList* change_list) {
+    syncer::SyncChangeList* change_list) {
   DCHECK(loaded_);
   DCHECK(sync_turl);
   DCHECK(local_turl);
   DCHECK(sync_turl->sync_guid() != local_turl->sync_guid());
   DCHECK(!local_turl->IsExtensionKeyword());
   DCHECK(change_list);
 
   const bool local_is_better =
       (local_turl->last_modified() > sync_turl->last_modified()) ||
       local_turl->created_by_policy() ||
       (local_turl == GetDefaultSearchProvider());
   const bool can_replace_local = CanReplace(local_turl);
   if (CanReplace(sync_turl) && (local_is_better || !can_replace_local)) {
-    csync::SyncData sync_data = CreateSyncDataFromTemplateURL(*sync_turl);
+    syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*sync_turl);
     change_list->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_DELETE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_DELETE, sync_data));
     return false;
   }
   if (can_replace_local) {
     // Since we're processing sync changes, the upcoming Remove() won't generate
     // an ACTION_DELETE.  We need to do it manually to keep the server in sync
     // with us.  Note that if we're being called from
     // MergeDataAndStartSyncing(), and this TemplateURL was pre-existing rather
     // than having just been brought down, then this is wrong, because the
     // server doesn't yet know about this entity; but in this case,
     // PruneSyncChanges() will prune out the ACTION_DELETE we create here.
-    csync::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
+    syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
     change_list->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_DELETE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_DELETE, sync_data));
     Remove(local_turl);
   } else if (local_is_better) {
     string16 new_keyword = UniquifyKeyword(*sync_turl);
     DCHECK(!GetTemplateURLForKeyword(new_keyword));
     sync_turl->data_.SetKeyword(new_keyword);
     // If we update the cloud TURL, we need to push an update back to sync
     // informing it that something has changed.
-    csync::SyncData sync_data = CreateSyncDataFromTemplateURL(*sync_turl);
+    syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*sync_turl);
     change_list->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_UPDATE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
   } else {
     string16 new_keyword = UniquifyKeyword(*local_turl);
     TemplateURLData data(local_turl->data());
     data.SetKeyword(new_keyword);
     TemplateURL new_turl(local_turl->profile(), data);
     UIThreadSearchTermsData search_terms_data(local_turl->profile());
     if (UpdateNoNotify(local_turl, new_turl, search_terms_data))
       NotifyObservers();
     // Since we're processing sync changes, the UpdateNoNotify() above didn't
     // generate an ACTION_UPDATE.  We need to do it manually to keep the server
     // in sync with us.  Note that if we're being called from
     // MergeDataAndStartSyncing(), and this TemplateURL was pre-existing rather
     // than having just been brought down, then this is wrong, because the
     // server won't know about this entity until it processes the ACTION_ADD our
     // caller will later generate; but in this case, PruneSyncChanges() will
     // prune out the ACTION_UPDATE we create here.
-    csync::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
+    syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
     change_list->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_UPDATE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
   }
   return true;
 }
 
 TemplateURL* TemplateURLService::FindDuplicateOfSyncTemplateURL(
     const TemplateURL& sync_turl) {
   TemplateURL* existing_turl = GetTemplateURLForKeyword(sync_turl.keyword());
   return existing_turl && (existing_turl->url() == sync_turl.url()) ?
       existing_turl : NULL;
 }
 
 void TemplateURLService::MergeSyncAndLocalURLDuplicates(
     TemplateURL* sync_turl,
     TemplateURL* local_turl,
-    csync::SyncChangeList* change_list) {
+    syncer::SyncChangeList* change_list) {
   DCHECK(loaded_);
   DCHECK(sync_turl);
   DCHECK(local_turl);
   DCHECK(change_list);
   scoped_ptr<TemplateURL> scoped_sync_turl(sync_turl);
   if (sync_turl->last_modified() > local_turl->last_modified()) {
     // Fully replace local_url with Sync's copy. Note that because use Add
     // rather than ResetTemplateURL, |sync_url| is added with a fresh
     // TemplateURLID. We don't need to sync the new ID back to the server since
     // it's only relevant locally.
     bool delete_default = (local_turl == GetDefaultSearchProvider());
     DCHECK(!delete_default || !is_default_search_managed_);
     if (delete_default)
       default_search_provider_ = NULL;
 
     // See comments in ResolveSyncKeywordConflict() regarding generating an
     // ACTION_DELETE manually since Remove() won't do it.
-    csync::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
+    syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
     change_list->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_DELETE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_DELETE, sync_data));
     Remove(local_turl);
 
     // Force the local ID to kInvalidTemplateURLID so we can add it.
     sync_turl->data_.id = kInvalidTemplateURLID;
     Add(scoped_sync_turl.release());
     if (delete_default)
       SetDefaultSearchProvider(sync_turl);
   } else {
     // Change the local TURL's GUID to the server's GUID and push an update to
     // Sync. This ensures that the rest of local_url's fields are sync'd up to
     // the server, and the next time local_url is synced, it is recognized by
     // having the same GUID.
     ResetTemplateURLGUID(local_turl, sync_turl->sync_guid());
-    csync::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
+    syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*local_turl);
     change_list->push_back(
-        csync::SyncChange(csync::SyncChange::ACTION_UPDATE, sync_data));
+        syncer::SyncChange(syncer::SyncChange::ACTION_UPDATE, sync_data));
   }
 }
 
 void TemplateURLService::SetDefaultSearchProviderIfNewlySynced(
     const std::string& guid) {
   // If we're not syncing or if default search is managed by policy, ignore.
   if (!sync_processor_.get() || is_default_search_managed_)
     return;
 
   PrefService* prefs = GetPrefs();
@@ skipping 32 matching lines @@
     // TODO(mpcomplete): If we allow editing extension keywords, then those
     // should be persisted to disk and synced.
     if (template_url->sync_guid().empty() &&
         !template_url->IsExtensionKeyword()) {
       template_url->data_.sync_guid = base::GenerateGUID();
       if (service_.get())
         service_->UpdateKeyword(template_url->data());
     }
   }
 }