[Sync] Rename csync namespace to syncer

chrome/browser/search_engines/template_url_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_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_
 #define CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 13 matching lines @@
 #include "sync/api/sync_change.h"
 #include "sync/api/syncable_service.h"
 
 class GURL;
 class PrefService;
 class Profile;
 class SearchHostToURLsMap;
 class SearchTermsData;
 class TemplateURLServiceObserver;
 
-namespace csync {
+namespace syncer {
 class SyncData;
 class SyncErrorFactory;
 }
 
 namespace extensions {
 class Extension;
 }
 
 namespace history {
 struct URLVisitedDetails;
@@ skipping 16 matching lines @@
 // OnTemplateURLServiceChanged as well as the TEMPLATE_URL_SERVICE_LOADED
 // notification message.
 //
 // TemplateURLService takes ownership of any TemplateURL passed to it. If there
 // is a WebDataService, deletion is handled by WebDataService, otherwise
 // TemplateURLService handles deletion.
 
 class TemplateURLService : public WebDataServiceConsumer,
                            public ProfileKeyedService,
                            public content::NotificationObserver,
-                           public csync::SyncableService {
+                           public syncer::SyncableService {
  public:
   typedef std::map<std::string, std::string> QueryTerms;
   typedef std::vector<TemplateURL*> TemplateURLVector;
   // Type for a static function pointer that acts as a time source.
   typedef base::Time(TimeProvider)();
-  typedef std::map<std::string, csync::SyncData> SyncDataMap;
+  typedef std::map<std::string, syncer::SyncData> SyncDataMap;
 
   // Struct used for initializing the data store with fake data.
   // Each initializer is mapped to a TemplateURL.
   struct Initializer {
     const char* const keyword;
     const char* const url;
     const char* const content;
   };
 
   explicit TemplateURLService(Profile* profile);
@@ skipping 170 matching lines @@
   // Returns the locale-direction-adjusted short name for the given keyword.
   // Also sets the out param to indicate whether the keyword belongs to an
   // extension.
   string16 GetKeywordShortName(const string16& keyword,
                                bool* is_extension_keyword);
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
-  // csync::SyncableService implementation.
+  // syncer::SyncableService implementation.
 
   // Returns all syncable TemplateURLs from this model as SyncData. This should
   // include every search engine and no Extension keywords.
-  virtual csync::SyncDataList GetAllSyncData(
+  virtual syncer::SyncDataList GetAllSyncData(
       syncable::ModelType type) const OVERRIDE;
   // Process new search engine changes from Sync, merging them into our local
   // data. This may send notifications if local search engines are added,
   // updated or removed.
-  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;
   // Merge initial search engine data from Sync and push any local changes up
   // to Sync. This may send notifications if local search engines are added,
   // updated or removed.
-  virtual csync::SyncError MergeDataAndStartSyncing(
+  virtual syncer::SyncError MergeDataAndStartSyncing(
       syncable::ModelType type,
-      const csync::SyncDataList& initial_sync_data,
-      scoped_ptr<csync::SyncChangeProcessor> sync_processor,
-      scoped_ptr<csync::SyncErrorFactory> sync_error_factory) OVERRIDE;
+      const syncer::SyncDataList& initial_sync_data,
+      scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
+      scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) OVERRIDE;
   virtual void StopSyncing(syncable::ModelType type) OVERRIDE;
 
   // Processes a local TemplateURL change for Sync. |turl| is the TemplateURL
   // that has been modified, and |type| is the Sync ChangeType that took place.
   // This may send a new SyncChange to the cloud. If our model has not yet been
   // associated with Sync, or if this is triggered by a Sync change, then this
   // does nothing.
   void ProcessTemplateURLChange(const TemplateURL* turl,
-                                csync::SyncChange::SyncChangeType type);
+                                syncer::SyncChange::SyncChangeType type);
 
   Profile* profile() const { return profile_; }
 
   // Returns a SyncData with a sync representation of the search engine data
   // from |turl|.
-  static csync::SyncData CreateSyncDataFromTemplateURL(const TemplateURL& turl);
+  static syncer::SyncData CreateSyncDataFromTemplateURL(
+      const TemplateURL& turl);
 
   // Creates a new heap-allocated TemplateURL* which is populated by overlaying
   // |sync_data| atop |existing_turl|.  |existing_turl| may be NULL; if not it
   // remains unmodified.  The caller owns the returned TemplateURL*.
   //
   // If the created TemplateURL is migrated in some way from out-of-date sync
   // data, an appropriate SyncChange is added to |change_list|.  If the sync
   // data is bad for some reason, an ACTION_DELETE change is added and the
   // function returns NULL.
   static TemplateURL* CreateTemplateURLFromTemplateURLAndSyncData(
       Profile* profile,
       TemplateURL* existing_turl,
-      const csync::SyncData& sync_data,
-      csync::SyncChangeList* change_list);
+      const syncer::SyncData& sync_data,
+      syncer::SyncChangeList* change_list);
 
-  // Returns a map mapping Sync GUIDs to pointers to csync::SyncData.
+  // Returns a map mapping Sync GUIDs to pointers to syncer::SyncData.
   static SyncDataMap CreateGUIDToSyncDataMap(
-      const csync::SyncDataList& sync_data);
+      const syncer::SyncDataList& sync_data);
 
 #if defined(UNIT_TEST)
   // Set a different time provider function, such as
   // base::MockTimeProvider::StaticNow, when testing calls to base::Time::Now.
   void set_time_provider(TimeProvider* time_provider) {
     time_provider_ = time_provider;
   }
 #endif
 
  protected:
@@ skipping 201 matching lines @@
 
   // Given a TemplateURL from Sync (cloud) and a local, non-extension
   // TemplateURL with the same keyword, selects "better" and "worse" entries:
   //   * If one of the TemplateURLs is replaceable and the other is not, the
   //     non-replaceable entry is better.
   //   * Otherwise, if |local_turl| was created by policy, is the default
   //     provider, or was modified more recently, it is better.
   //   * Otherwise |sync_turl| is better.
   // Then resolves the conflict:
   //   * If the "worse" entry is |sync_turl|, and it is replaceable, add a
-  //     csync::SyncChange to delete it, and return false.
+  //     syncer::SyncChange to delete it, and return false.
   //   * If the "worse" entry is |local_turl|, and it is replaceable, remove it
   //     from the service and return true.
   //   * Otherwise, uniquify the keyword of the "worse" entry.  If it is
   //     |local_turl|, update it within the service.  Add a SyncChange to update
   //     things (always for |sync_turl|, sometimes for |local_turl|; see
   //     comments in implementation), and return true.
   // When the function returns true, callers can then go ahead and add or update
   // |sync_turl| within the service.  If it returns false, callers must not add
   // the |sync_turl|, and must Remove() the |sync_turl| if it was being updated.
   // (Be careful; calling Remove() could add an ACTION_DELETE sync change, which
   // this function has already done.  Make sure to avoid duplicates.)
   //
   // Note that we never call this for conflicts with extension keywords because
   // other code (e.g. AddToMaps()) is responsible for correctly prioritizing
   // extension- vs. non-extension-based TemplateURLs with the same keyword.
   bool ResolveSyncKeywordConflict(TemplateURL* sync_turl,
                                   TemplateURL* local_turl,
-                                  csync::SyncChangeList* change_list);
+                                  syncer::SyncChangeList* change_list);
 
   // Returns a TemplateURL from the service that has the same keyword and search
   // URL as |sync_turl|, if it exists.
   TemplateURL* FindDuplicateOfSyncTemplateURL(const TemplateURL& sync_turl);
 
   // Given a TemplateURL from the cloud and a local matching duplicate found by
   // FindDuplicateOfSyncTemplateURL, merges the two. If |sync_turl| is newer,
   // this replaces |local_turl| with |sync_turl| using the service's Remove and
   // Add. If |local_turl| is newer, this replaces |sync_turl| with |local_turl|
   // through through adding appropriate SyncChanges to |change_list|. This
   // method takes ownership of |sync_turl|, and adds it to the model if it is
   // newer, so the caller must release it if need be.
   void MergeSyncAndLocalURLDuplicates(TemplateURL* sync_turl,
                                       TemplateURL* local_turl,
-                                      csync::SyncChangeList* change_list);
+                                      syncer::SyncChangeList* change_list);
 
   // Checks a newly added TemplateURL from Sync by its sync_guid and sets it as
   // the default search provider if we were waiting for it.
   void SetDefaultSearchProviderIfNewlySynced(const std::string& guid);
 
   // Retrieve the pending default search provider according to Sync. Returns
   // NULL if there was no pending search provider from Sync.
   TemplateURL* GetPendingSyncedDefaultSearchProvider();
 
   // Goes through a vector of TemplateURLs and ensure that both the in-memory
@@ skipping 64 matching lines @@
   // Do we have an active association between the TemplateURLs and sync models?
   // Set in MergeDataAndStartSyncing, reset in StopSyncing. While this is not
   // set, we ignore any local search engine changes (when we start syncing we
   // will look up the most recent values anyways).
   bool models_associated_;
 
   // Whether we're currently processing changes from the syncer. While this is
   // true, we ignore any local search engine changes, since we triggered them.
   bool processing_syncer_changes_;
 
-  // Sync's csync::SyncChange handler. We push all our changes through this.
-  scoped_ptr<csync::SyncChangeProcessor> sync_processor_;
+  // Sync's syncer::SyncChange handler. We push all our changes through this.
+  scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
 
   // Sync's error handler. We use it to create a sync error.
-  scoped_ptr<csync::SyncErrorFactory> sync_error_factory_;
+  scoped_ptr<syncer::SyncErrorFactory> sync_error_factory_;
 
   // Whether or not we are waiting on the default search provider to come in
   // from Sync. This is to facilitate the fact that changes to the value of
   // prefs::kSyncedDefaultSearchProviderGUID do not always come before the
   // TemplateURL entry it refers to, and to handle the case when we want to use
   // the Synced default when the default search provider becomes unmanaged.
   bool pending_synced_default_search_;
 
   // A set of sync GUIDs denoting TemplateURLs that have been removed from this
   // model or the underlying WebDataService prior to MergeDataAndStartSyncing.
   // This set is used to determine what entries from the server we want to
   // ignore locally and return a delete command for.
   std::set<std::string> pre_sync_deletes_;
 
   // This is used to log the origin of changes to the default search provider.
   // We set this value to increasingly specific values when we know what is the
   // cause/origin of a default search change.
   DefaultSearchChangeOrigin dsp_change_origin_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLService);
 };
 
 #endif  // CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_