[Sync] Put everything in sync/api into csync namespace

chrome/browser/webdata/autofill_profile_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/autofill_profile_syncable_service.h"
 
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
@@ skipping 39 matching lines @@
 
 AutofillProfileSyncableService::~AutofillProfileSyncableService() {
   DCHECK(CalledOnValidThread());
 }
 
 AutofillProfileSyncableService::AutofillProfileSyncableService()
     : web_data_service_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 }
 
-SyncError AutofillProfileSyncableService::MergeDataAndStartSyncing(
+csync::SyncError AutofillProfileSyncableService::MergeDataAndStartSyncing(
     syncable::ModelType type,
-    const SyncDataList& initial_sync_data,
-    scoped_ptr<SyncChangeProcessor> sync_processor,
-    scoped_ptr<SyncErrorFactory> sync_error_factory) {
+    const csync::SyncDataList& initial_sync_data,
+    scoped_ptr<csync::SyncChangeProcessor> sync_processor,
+    scoped_ptr<csync::SyncErrorFactory> sync_error_factory) {
   DCHECK(CalledOnValidThread());
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
   DVLOG(1) << "Associating Autofill: MergeDataAndStartSyncing";
 
   sync_error_factory_ = sync_error_factory.Pass();
   if (!LoadAutofillData(&profiles_.get())) {
     return sync_error_factory_->CreateAndUploadError(
         FROM_HERE, "Could not get the autofill data from WebDatabase.");
@@ skipping 13 matching lines @@
     }
   }
 
   sync_processor_ = sync_processor.Pass();
 
   GUIDToProfileMap remaining_profiles;
   CreateGUIDToProfileMap(profiles_.get(), &remaining_profiles);
 
   DataBundle bundle;
   // Go through and check for all the profiles that sync already knows about.
-  for (SyncDataList::const_iterator sync_iter = initial_sync_data.begin();
+  for (csync::SyncDataList::const_iterator sync_iter =
+           initial_sync_data.begin();
        sync_iter != initial_sync_data.end();
        ++sync_iter) {
     GUIDToProfileMap::iterator it =
         CreateOrUpdateProfile(*sync_iter, &remaining_profiles, &bundle);
     // |it| points to created/updated profile. Add it to the |profiles_map_| and
     // then remove it from |remaining_profiles|. After this loop is completed
     // |remaining_profiles| will have only those profiles that are not in the
     // sync.
     profiles_map_[it->first] = it->second;
     remaining_profiles.erase(it);
@@ skipping 19 matching lines @@
       remaining_profiles.erase(profile_to_merge);
     }
   }
 
   if (!SaveChangesToWebData(bundle)) {
     return sync_error_factory_->CreateAndUploadError(
         FROM_HERE,
         "Failed to update webdata.");
   }
 
-  SyncChangeList new_changes;
+  csync::SyncChangeList new_changes;
   for (GUIDToProfileMap::iterator i = remaining_profiles.begin();
        i != remaining_profiles.end(); ++i) {
     new_changes.push_back(
-        SyncChange(SyncChange::ACTION_ADD, CreateData(*(i->second))));
+        csync::SyncChange(
+            csync::SyncChange::ACTION_ADD, CreateData(*(i->second))));
     profiles_map_[i->first] = i->second;
   }
 
   for (size_t i = 0; i < bundle.profiles_to_sync_back.size(); ++i) {
     new_changes.push_back(
-        SyncChange(SyncChange::ACTION_UPDATE,
+        csync::SyncChange(csync::SyncChange::ACTION_UPDATE,
                    CreateData(*(bundle.profiles_to_sync_back[i]))));
   }
 
-  SyncError error;
+  csync::SyncError error;
   if (!new_changes.empty())
     error = sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
 
   WebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
 
   return error;
 }
 
 void AutofillProfileSyncableService::StopSyncing(syncable::ModelType type) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, syncable::AUTOFILL_PROFILE);
 
   sync_processor_.reset();
   sync_error_factory_.reset();
   profiles_.reset();
   profiles_map_.clear();
 }
 
-SyncDataList AutofillProfileSyncableService::GetAllSyncData(
+csync::SyncDataList AutofillProfileSyncableService::GetAllSyncData(
     syncable::ModelType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_processor_.get());
   DCHECK_EQ(type, syncable::AUTOFILL_PROFILE);
 
-  SyncDataList current_data;
+  csync::SyncDataList current_data;
 
   for (GUIDToProfileMap::const_iterator i = profiles_map_.begin();
        i != profiles_map_.end(); ++i) {
     current_data.push_back(CreateData(*(i->second)));
   }
   return current_data;
 }
 
-SyncError AutofillProfileSyncableService::ProcessSyncChanges(
+csync::SyncError AutofillProfileSyncableService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
-    const SyncChangeList& change_list) {
+    const csync::SyncChangeList& change_list) {
   DCHECK(CalledOnValidThread());
   if (!sync_processor_.get()) {
-    SyncError error(FROM_HERE, "Models not yet associated.",
+    csync::SyncError error(FROM_HERE, "Models not yet associated.",
                     syncable::AUTOFILL_PROFILE);
     return error;
   }
 
   DataBundle bundle;
 
-  for (SyncChangeList::const_iterator i = change_list.begin();
+  for (csync::SyncChangeList::const_iterator i = change_list.begin();
        i != change_list.end(); ++i) {
     DCHECK(i->IsValid());
     switch (i->change_type()) {
-      case SyncChange::ACTION_ADD:
-      case SyncChange::ACTION_UPDATE:
+      case csync::SyncChange::ACTION_ADD:
+      case csync::SyncChange::ACTION_UPDATE:
         CreateOrUpdateProfile(i->sync_data(), &profiles_map_, &bundle);
         break;
-      case SyncChange::ACTION_DELETE: {
+      case csync::SyncChange::ACTION_DELETE: {
         std::string guid = i->sync_data().GetSpecifics().
              autofill_profile().guid();
         bundle.profiles_to_delete.push_back(guid);
         profiles_map_.erase(guid);
       } break;
       default:
         NOTREACHED() << "Unexpected sync change state.";
         return sync_error_factory_->CreateAndUploadError(
               FROM_HERE,
               "ProcessSyncChanges failed on ChangeType " +
-                  SyncChange::ChangeTypeToString(i->change_type()));
+                  csync::SyncChange::ChangeTypeToString(i->change_type()));
     }
   }
 
   if (!SaveChangesToWebData(bundle)) {
     return sync_error_factory_->CreateAndUploadError(
         FROM_HERE,
         "Failed to update webdata.");
   }
 
   WebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
 
-  return SyncError();
+  return csync::SyncError();
 }
 
 void AutofillProfileSyncableService::Observe(int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED);
   DCHECK_EQ(web_data_service_, content::Source<WebDataService>(source).ptr());
   // Check if sync is on. If we receive notification prior to the sync being set
   // up we are going to process all when MergeData..() is called. If we receive
   // notification after the sync exited, it will be sinced next time Chrome
@@ skipping 121 matching lines @@
     const std::vector<AutofillProfile*>& profiles,
     GUIDToProfileMap* profile_map) {
   DCHECK(profile_map);
   profile_map->clear();
   for (size_t i = 0; i < profiles.size(); ++i)
     (*profile_map)[profiles[i]->guid()] = profiles[i];
 }
 
 AutofillProfileSyncableService::GUIDToProfileMap::iterator
 AutofillProfileSyncableService::CreateOrUpdateProfile(
-    const SyncData& data, GUIDToProfileMap* profile_map, DataBundle* bundle) {
+    const csync::SyncData& data,
+    GUIDToProfileMap* profile_map,
+    DataBundle* bundle) {
   DCHECK(profile_map);
   DCHECK(bundle);
 
   DCHECK_EQ(syncable::AUTOFILL_PROFILE, data.GetDataType());
 
   const sync_pb::EntitySpecifics& specifics = data.GetSpecifics();
   const sync_pb::AutofillProfileSpecifics& autofill_specifics(
       specifics.autofill_profile());
 
   GUIDToProfileMap::iterator it = profile_map->find(
@@ skipping 36 matching lines @@
   }
   return it;
 }
 
 void AutofillProfileSyncableService::ActOnChange(
      const AutofillProfileChange& change) {
   DCHECK((change.type() == AutofillProfileChange::REMOVE &&
           !change.profile()) ||
          (change.type() != AutofillProfileChange::REMOVE && change.profile()));
   DCHECK(sync_processor_.get());
-  SyncChangeList new_changes;
+  csync::SyncChangeList new_changes;
   DataBundle bundle;
   switch (change.type()) {
     case AutofillProfileChange::ADD:
       new_changes.push_back(
-          SyncChange(SyncChange::ACTION_ADD, CreateData(*(change.profile()))));
+          csync::SyncChange(
+              csync::SyncChange::ACTION_ADD, CreateData(*(change.profile()))));
       DCHECK(profiles_map_.find(change.profile()->guid()) ==
              profiles_map_.end());
       profiles_.push_back(new AutofillProfile(*(change.profile())));
       profiles_map_[change.profile()->guid()] = profiles_.get().back();
       break;
     case AutofillProfileChange::UPDATE: {
       GUIDToProfileMap::iterator it = profiles_map_.find(
           change.profile()->guid());
       DCHECK(it != profiles_map_.end());
       *(it->second) = *(change.profile());
       new_changes.push_back(
-          SyncChange(SyncChange::ACTION_UPDATE,
+          csync::SyncChange(csync::SyncChange::ACTION_UPDATE,
                      CreateData(*(change.profile()))));
       break;
     }
     case AutofillProfileChange::REMOVE: {
       AutofillProfile empty_profile(change.key());
-      new_changes.push_back(SyncChange(SyncChange::ACTION_DELETE,
+      new_changes.push_back(csync::SyncChange(csync::SyncChange::ACTION_DELETE,
                                        CreateData(empty_profile)));
       profiles_map_.erase(change.key());
       break;
     }
     default:
       NOTREACHED();
   }
-  SyncError error = sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
+  csync::SyncError error =
+      sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
   if (error.IsSet()) {
     // TODO(isherman): Investigating http://crbug.com/121592
     VLOG(1) << "[AUTOFILL SYNC] "
             << "Failed processing change:\n"
             << "  Error: " << error.message() << "\n"
             << "  Guid: " << change.key();
   }
 }
 
-SyncData AutofillProfileSyncableService::CreateData(
+csync::SyncData AutofillProfileSyncableService::CreateData(
     const AutofillProfile& profile) {
   sync_pb::EntitySpecifics specifics;
   WriteAutofillProfile(profile, &specifics);
-  return SyncData::CreateLocalData(profile.guid(), profile.guid(), specifics);
+  return
+      csync::SyncData::CreateLocalData(
+          profile.guid(), profile.guid(), specifics);
 }
 
 bool AutofillProfileSyncableService::UpdateField(
     AutofillFieldType field_type,
     const std::string& new_value,
     AutofillProfile* autofill_profile) {
   if (UTF16ToUTF8(autofill_profile->GetInfo(field_type)) == new_value)
     return false;
   autofill_profile->SetInfo(field_type, UTF8ToUTF16(new_value));
   return true;
@@ skipping 32 matching lines @@
 }
 
 AutofillTable* AutofillProfileSyncableService::GetAutofillTable() const {
   return web_data_service_->GetDatabase()->GetAutofillTable();
 }
 
 AutofillProfileSyncableService::DataBundle::DataBundle() {}
 
 AutofillProfileSyncableService::DataBundle::~DataBundle() {
 }