[Sync] Rename csync namespace to syncer

chrome/browser/webdata/autocomplete_syncable_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/webdata/autocomplete_syncable_service.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 89 matching lines @@
 
 AutocompleteSyncableService::~AutocompleteSyncableService() {
   DCHECK(CalledOnValidThread());
 }
 
 AutocompleteSyncableService::AutocompleteSyncableService()
     : web_data_service_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 }
 
-csync::SyncError AutocompleteSyncableService::MergeDataAndStartSyncing(
+syncer::SyncError AutocompleteSyncableService::MergeDataAndStartSyncing(
     syncable::ModelType type,
-    const csync::SyncDataList& initial_sync_data,
-    scoped_ptr<csync::SyncChangeProcessor> sync_processor,
-    scoped_ptr<csync::SyncErrorFactory> error_handler) {
+    const syncer::SyncDataList& initial_sync_data,
+    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
+    scoped_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK(CalledOnValidThread());
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(error_handler.get());
   VLOG(1) << "Associating Autocomplete: MergeDataAndStartSyncing";
 
   error_handler_ = error_handler.Pass();
   std::vector<AutofillEntry> entries;
   if (!LoadAutofillData(&entries)) {
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Could not get the autocomplete data from WebDatabase.");
   }
 
   AutocompleteEntryMap new_db_entries;
   for (std::vector<AutofillEntry>::iterator it = entries.begin();
        it != entries.end(); ++it) {
     new_db_entries[it->key()] =
-        std::make_pair(csync::SyncChange::ACTION_ADD, it);
+        std::make_pair(syncer::SyncChange::ACTION_ADD, it);
   }
 
   sync_processor_ = sync_processor.Pass();
 
   std::vector<AutofillEntry> new_synced_entries;
   // Go through and check for all the entries that sync already knows about.
   // CreateOrUpdateEntry() will remove entries that are same with the synced
   // ones from |new_db_entries|.
-  for (csync::SyncDataList::const_iterator sync_iter =
+  for (syncer::SyncDataList::const_iterator sync_iter =
            initial_sync_data.begin();
        sync_iter != initial_sync_data.end(); ++sync_iter) {
     CreateOrUpdateEntry(*sync_iter, &new_db_entries, &new_synced_entries);
   }
 
   if (!SaveChangesToWebData(new_synced_entries)) {
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Failed to update webdata.");
   }
 
   WebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
 
-  csync::SyncChangeList new_changes;
+  syncer::SyncChangeList new_changes;
   for (AutocompleteEntryMap::iterator i = new_db_entries.begin();
        i != new_db_entries.end(); ++i) {
     new_changes.push_back(
-        csync::SyncChange(
+        syncer::SyncChange(
             i->second.first, CreateSyncData(*(i->second.second))));
   }
 
   if (ShouldCullSyncedData()) {
     // This will schedule a deletion operation on the DB thread, which will
     // trigger a notification to propagate the deletion to Sync.
     web_data_service_->RemoveExpiredFormElements();
   }
 
-  csync::SyncError error =
+  syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
 
   return error;
 }
 
 void AutocompleteSyncableService::StopSyncing(syncable::ModelType type) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(syncable::AUTOFILL, type);
 
   sync_processor_.reset(NULL);
   error_handler_.reset();
 }
 
-csync::SyncDataList AutocompleteSyncableService::GetAllSyncData(
+syncer::SyncDataList AutocompleteSyncableService::GetAllSyncData(
     syncable::ModelType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_processor_.get());
   DCHECK_EQ(type, syncable::AUTOFILL);
 
-  csync::SyncDataList current_data;
+  syncer::SyncDataList current_data;
 
   std::vector<AutofillEntry> entries;
   if (!LoadAutofillData(&entries))
     return current_data;
 
   for (std::vector<AutofillEntry>::iterator it = entries.begin();
        it != entries.end(); ++it) {
     current_data.push_back(CreateSyncData(*it));
   }
 
   return current_data;
 }
 
-csync::SyncError AutocompleteSyncableService::ProcessSyncChanges(
+syncer::SyncError AutocompleteSyncableService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const csync::SyncChangeList& change_list) {
+    const syncer::SyncChangeList& change_list) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_processor_.get());
 
   if (!sync_processor_.get()) {
-    csync::SyncError error(FROM_HERE, "Models not yet associated.",
+    syncer::SyncError error(FROM_HERE, "Models not yet associated.",
                     syncable::AUTOFILL);
     return error;
   }
 
   // Data is loaded only if we get new ADD/UPDATE change.
   std::vector<AutofillEntry> entries;
   scoped_ptr<AutocompleteEntryMap> db_entries;
   std::vector<AutofillEntry> new_entries;
 
-  csync::SyncError list_processing_error;
+  syncer::SyncError list_processing_error;
 
-  for (csync::SyncChangeList::const_iterator i = change_list.begin();
+  for (syncer::SyncChangeList::const_iterator i = change_list.begin();
        i != change_list.end() && !list_processing_error.IsSet(); ++i) {
     DCHECK(i->IsValid());
     switch (i->change_type()) {
-      case csync::SyncChange::ACTION_ADD:
-      case csync::SyncChange::ACTION_UPDATE:
+      case syncer::SyncChange::ACTION_ADD:
+      case syncer::SyncChange::ACTION_UPDATE:
         if (!db_entries.get()) {
           if (!LoadAutofillData(&entries)) {
             return error_handler_->CreateAndUploadError(
                 FROM_HERE,
                 "Could not get the autocomplete data from WebDatabase.");
           }
           db_entries.reset(new AutocompleteEntryMap);
           for (std::vector<AutofillEntry>::iterator it = entries.begin();
                it != entries.end(); ++it) {
             (*db_entries)[it->key()] =
-                std::make_pair(csync::SyncChange::ACTION_ADD, it);
+                std::make_pair(syncer::SyncChange::ACTION_ADD, it);
           }
         }
         CreateOrUpdateEntry(i->sync_data(), db_entries.get(), &new_entries);
         break;
-      case csync::SyncChange::ACTION_DELETE: {
+      case syncer::SyncChange::ACTION_DELETE: {
         DCHECK(i->sync_data().GetSpecifics().has_autofill())
             << "Autofill specifics data not present on delete!";
         const sync_pb::AutofillSpecifics& autofill =
             i->sync_data().GetSpecifics().autofill();
         if (autofill.has_value()) {
           list_processing_error = AutofillEntryDelete(autofill);
         } else {
           DLOG(WARNING)
               << "Delete for old-style autofill profile being dropped!";
         }
       } break;
       default:
         NOTREACHED() << "Unexpected sync change state.";
         return error_handler_->CreateAndUploadError(
             FROM_HERE,
             "ProcessSyncChanges failed on ChangeType " +
-                 csync::SyncChange::ChangeTypeToString(i->change_type()));
+                 syncer::SyncChange::ChangeTypeToString(i->change_type()));
     }
   }
 
   if (!SaveChangesToWebData(new_entries)) {
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Failed to update webdata.");
   }
 
   WebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
@@ skipping 40 matching lines @@
   if (!new_entries.empty() &&
       !web_data_service_->GetDatabase()->
           GetAutofillTable()->UpdateAutofillEntries(new_entries)) {
     return false;
   }
   return true;
 }
 
 // Creates or updates an autocomplete entry based on |data|.
 void AutocompleteSyncableService::CreateOrUpdateEntry(
-    const csync::SyncData& data,
+    const syncer::SyncData& data,
     AutocompleteEntryMap* loaded_data,
     std::vector<AutofillEntry>* new_entries) {
   const sync_pb::EntitySpecifics& specifics = data.GetSpecifics();
   const sync_pb::AutofillSpecifics& autofill_specifics(
       specifics.autofill());
 
   if (!autofill_specifics.has_value()) {
     DLOG(WARNING)
         << "Add/Update for old-style autofill profile being dropped!";
     return;
@@ skipping 20 matching lines @@
   } else {
     // Entry already present - merge if necessary.
     std::vector<base::Time> timestamps;
     bool different = MergeTimestamps(
         autofill_specifics, it->second.second->timestamps(), &timestamps);
     if (different) {
       AutofillEntry new_entry(it->second.second->key(), timestamps);
       new_entries->push_back(new_entry);
       // Update the sync db if the list of timestamps have changed.
       *(it->second.second) = new_entry;
-      it->second.first = csync::SyncChange::ACTION_UPDATE;
+      it->second.first = syncer::SyncChange::ACTION_UPDATE;
     } else {
       loaded_data->erase(it);
     }
   }
 }
 
 // static
 void AutocompleteSyncableService::WriteAutofillEntry(
     const AutofillEntry& entry, sync_pb::EntitySpecifics* autofill_specifics) {
   sync_pb::AutofillSpecifics* autofill =
       autofill_specifics->mutable_autofill();
   autofill->set_name(UTF16ToUTF8(entry.key().name()));
   autofill->set_value(UTF16ToUTF8(entry.key().value()));
   const std::vector<base::Time>& ts(entry.timestamps());
   for (std::vector<base::Time>::const_iterator timestamp = ts.begin();
        timestamp != ts.end(); ++timestamp) {
     autofill->add_usage_timestamp(timestamp->ToInternalValue());
   }
 }
 
-csync::SyncError AutocompleteSyncableService::AutofillEntryDelete(
+syncer::SyncError AutocompleteSyncableService::AutofillEntryDelete(
     const sync_pb::AutofillSpecifics& autofill) {
   if (!web_data_service_->GetDatabase()->GetAutofillTable()->RemoveFormElement(
           UTF8ToUTF16(autofill.name()), UTF8ToUTF16(autofill.value()))) {
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Could not remove autocomplete entry from WebDatabase.");
   }
-  return csync::SyncError();
+  return syncer::SyncError();
 }
 
 void AutocompleteSyncableService::ActOnChanges(
      const AutofillChangeList& changes) {
   DCHECK(sync_processor_.get());
-  csync::SyncChangeList new_changes;
+  syncer::SyncChangeList new_changes;
   for (AutofillChangeList::const_iterator change = changes.begin();
        change != changes.end(); ++change) {
     switch (change->type()) {
       case AutofillChange::ADD:
       case AutofillChange::UPDATE: {
         std::vector<base::Time> timestamps;
         if (!web_data_service_->GetDatabase()->
                 GetAutofillTable()->GetAutofillTimestamps(
                     change->key().name(),
                     change->key().value(),
                     &timestamps)) {
           NOTREACHED();
           return;
         }
         AutofillEntry entry(change->key(), timestamps);
-        csync::SyncChange::SyncChangeType change_type =
+        syncer::SyncChange::SyncChangeType change_type =
            (change->type() == AutofillChange::ADD) ?
-               csync::SyncChange::ACTION_ADD : csync::SyncChange::ACTION_UPDATE;
-        new_changes.push_back(csync::SyncChange(change_type,
+            syncer::SyncChange::ACTION_ADD :
+            syncer::SyncChange::ACTION_UPDATE;
+        new_changes.push_back(syncer::SyncChange(change_type,
                                          CreateSyncData(entry)));
         break;
       }
       case AutofillChange::REMOVE: {
         std::vector<base::Time> timestamps;
         AutofillEntry entry(change->key(), timestamps);
         new_changes.push_back(
-            csync::SyncChange(csync::SyncChange::ACTION_DELETE,
+            syncer::SyncChange(syncer::SyncChange::ACTION_DELETE,
                               CreateSyncData(entry)));
         break;
       }
       default:
         NOTREACHED();
         break;
     }
   }
-  csync::SyncError error =
+  syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
   if (error.IsSet()) {
     DLOG(WARNING) << "[AUTOCOMPLETE SYNC]"
                   << " Failed processing change:"
                   << " Error:" << error.message();
   }
 }
 
-csync::SyncData AutocompleteSyncableService::CreateSyncData(
+syncer::SyncData AutocompleteSyncableService::CreateSyncData(
     const AutofillEntry& entry) const {
   sync_pb::EntitySpecifics autofill_specifics;
   WriteAutofillEntry(entry, &autofill_specifics);
   std::string tag(KeyToTag(UTF16ToUTF8(entry.key().name()),
                            UTF16ToUTF8(entry.key().value())));
-  return csync::SyncData::CreateLocalData(tag, tag, autofill_specifics);
+  return syncer::SyncData::CreateLocalData(tag, tag, autofill_specifics);
 }
 
 // static
 std::string AutocompleteSyncableService::KeyToTag(const std::string& name,
                                                   const std::string& value) {
   std::string ns(kAutofillEntryNamespaceTag);
   return ns + net::EscapePath(name) + "|" + net::EscapePath(value);
 }