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

chrome/browser/webdata/autofill_profile_syncable_service.h

 // 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.
 #ifndef CHROME_BROWSER_WEBDATA_AUTOFILL_PROFILE_SYNCABLE_SERVICE_H_
 #define CHROME_BROWSER_WEBDATA_AUTOFILL_PROFILE_SYNCABLE_SERVICE_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 20 matching lines @@
 class ProfileSyncServiceAutofillTest;
 class WebDataService;
 
 extern const char kAutofillProfileTag[];
 
 // The sync implementation for AutofillProfiles.
 // MergeDataAndStartSyncing() called first, it does cloud->local and
 // local->cloud syncs. Then for each cloud change we receive
 // ProcessSyncChanges() and for each local change Observe() is called.
 class AutofillProfileSyncableService
-    : public SyncableService,
+    : public csync::SyncableService,
       public content::NotificationObserver,
       public base::NonThreadSafe {
  public:
   explicit AutofillProfileSyncableService(WebDataService* web_data_service);
   virtual ~AutofillProfileSyncableService();
 
   static syncable::ModelType model_type() { return syncable::AUTOFILL_PROFILE; }
 
-  // SyncableService implementation.
-  virtual SyncError MergeDataAndStartSyncing(
+  // csync::SyncableService implementation.
+  virtual csync::SyncError MergeDataAndStartSyncing(
       syncable::ModelType type,
-      const SyncDataList& initial_sync_data,
-      scoped_ptr<SyncChangeProcessor> sync_processor,
-      scoped_ptr<SyncErrorFactory> sync_error_factory) OVERRIDE;
+      const csync::SyncDataList& initial_sync_data,
+      scoped_ptr<csync::SyncChangeProcessor> sync_processor,
+      scoped_ptr<csync::SyncErrorFactory> sync_error_factory) OVERRIDE;
   virtual void StopSyncing(syncable::ModelType type) OVERRIDE;
-  virtual SyncDataList GetAllSyncData(syncable::ModelType type) const OVERRIDE;
-  virtual SyncError ProcessSyncChanges(
+  virtual csync::SyncDataList GetAllSyncData(
+      syncable::ModelType type) const OVERRIDE;
+  virtual csync::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
-      const SyncChangeList& change_list) OVERRIDE;
+      const csync::SyncChangeList& change_list) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  protected:
   // A convenience wrapper of a bunch of state we pass around while
   // associating models, and send to the WebDatabase for persistence.
   // We do this so we hold the write lock for only a small period.
@@ skipping 44 matching lines @@
   // fast processing of the changes.
   void CreateGUIDToProfileMap(const std::vector<AutofillProfile*>& profiles,
                               GUIDToProfileMap* profile_map);
 
   // Creates or updates a profile based on |data|. Looks at the guid of the data
   // and if a profile with such guid is present in |profile_map| updates it. If
   // not, searches through it for similar profiles. If similar profile is
   // found substitutes it for the new one, otherwise adds a new profile. Returns
   // iterator pointing to added/updated profile.
   GUIDToProfileMap::iterator CreateOrUpdateProfile(
-      const SyncData& data, GUIDToProfileMap* profile_map, DataBundle* bundle);
+      const csync::SyncData& data,
+      GUIDToProfileMap* profile_map,
+      DataBundle* bundle);
 
   // Syncs |change| to the cloud.
   void ActOnChange(const AutofillProfileChange& change);
 
-  // Creates SyncData based on supplied |profile|.
-  static SyncData CreateData(const AutofillProfile& profile);
+  // Creates csync::SyncData based on supplied |profile|.
+  static csync::SyncData CreateData(const AutofillProfile& profile);
 
   AutofillTable* GetAutofillTable() const;
 
   // Helper to compare the local value and cloud value of a field, copy into
   // the local value if they differ, and return whether the change happened.
   static bool UpdateField(AutofillFieldType field_type,
                           const std::string& new_value,
                           AutofillProfile* autofill_profile);
   // The same as |UpdateField|, but for multi-valued fields.
   static bool UpdateMultivaluedField(
       AutofillFieldType field_type,
       const ::google::protobuf::RepeatedPtrField<std::string>& new_value,
       AutofillProfile* autofill_profile);
 
   // Calls merge_into->OverwriteWithOrAddTo() and then checks if the
   // |merge_into| has extra data. Returns |true| if |merge_into| posseses some
   // multi-valued field values that are not in |merge_from|, false otherwise.
   static bool MergeProfile(const AutofillProfile& merge_from,
                            AutofillProfile* merge_into);
 
   // For unit-tests.
   AutofillProfileSyncableService();
-  void set_sync_processor(SyncChangeProcessor* sync_processor) {
+  void set_sync_processor(csync::SyncChangeProcessor* sync_processor) {
     sync_processor_.reset(sync_processor);
   }
 
   WebDataService* web_data_service_;  // WEAK
   content::NotificationRegistrar notification_registrar_;
 
   // Cached Autofill profiles. *Warning* deleted profiles are still in the
   // vector - use the |profiles_map_| to iterate through actual profiles.
   ScopedVector<AutofillProfile> profiles_;
   GUIDToProfileMap profiles_map_;
 
-  scoped_ptr<SyncChangeProcessor> sync_processor_;
+  scoped_ptr<csync::SyncChangeProcessor> sync_processor_;
 
-  scoped_ptr<SyncErrorFactory> sync_error_factory_;
+  scoped_ptr<csync::SyncErrorFactory> sync_error_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AutofillProfileSyncableService);
 };
 
 // This object is used in unit-tests as well, so it defined here.
 struct AutofillProfileSyncableService::DataBundle {
   DataBundle();
   ~DataBundle();
 
   std::vector<std::string> profiles_to_delete;
   std::vector<AutofillProfile*> profiles_to_update;
   std::vector<AutofillProfile*> profiles_to_add;
 
   // When we go through sync we find profiles that are similar but unmatched.
   // Merge such profiles.
   GUIDToProfileMap candidates_to_merge;
   // Profiles that have multi-valued fields that are not in sync.
   std::vector<AutofillProfile*> profiles_to_sync_back;
 };
 
 #endif  // CHROME_BROWSER_WEBDATA_AUTOFILL_PROFILE_SYNCABLE_SERVICE_H_