[Sync] Rename csync namespace to syncer

chrome/browser/sync/profile_sync_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_SYNC_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #pragma once
 
 #include <list>
 #include <string>
@@ skipping 35 matching lines @@
 
 namespace browser_sync {
 class BackendMigrator;
 class ChangeProcessor;
 class DataTypeManager;
 class JsController;
 class SessionModelAssociator;
 namespace sessions { class SyncSessionSnapshot; }
 }
 
-namespace csync {
+namespace syncer {
 class BaseTransaction;
 struct SyncCredentials;
 struct UserShare;
 }
 
 namespace sync_pb {
 class EncryptedData;
 }  // namespace sync_pb
 
 // ProfileSyncService is the layer between browser subsystems like bookmarks,
@@ skipping 73 matching lines @@
 //   When SetSyncSetupCompleted() == false, but SetSetupInProgress(true) has
 //   been called, then the sync engine knows not to download any user data.
 //
 //   When initial sync is complete, the UI code should call
 //   SetSyncSetupCompleted() followed by SetSetupInProgress(false) - this will
 //   tell the sync engine that setup is completed and it can begin downloading
 //   data from the sync server.
 //
 class ProfileSyncService : public browser_sync::SyncFrontend,
                            public browser_sync::SyncPrefObserver,
-                           public csync::UnrecoverableErrorHandler,
+                           public syncer::UnrecoverableErrorHandler,
                            public content::NotificationObserver,
                            public ProfileKeyedService {
  public:
   typedef ProfileSyncServiceObserver Observer;
   typedef browser_sync::SyncBackendHost::Status Status;
 
   enum SyncEventCodes  {
     MIN_SYNC_EVENT_CODE = 0,
 
     // Events starting the sync service.
@@ skipping 86 matching lines @@
 
   // Disables sync for user. Use ShowLoginDialog to enable.
   virtual void DisableForUser();
 
   // Whether sync is enabled by user or not.
   virtual bool HasSyncSetupCompleted() const;
   virtual void SetSyncSetupCompleted();
 
   // SyncFrontend implementation.
   virtual void OnBackendInitialized(
-      const csync::WeakHandle<csync::JsBackend>& js_backend,
+      const syncer::WeakHandle<syncer::JsBackend>& js_backend,
       bool success) OVERRIDE;
   virtual void OnSyncCycleCompleted() OVERRIDE;
   virtual void OnSyncConfigureRetry() OVERRIDE;
   virtual void OnConnectionStatusChange(
-      csync::ConnectionStatus status) OVERRIDE;
+      syncer::ConnectionStatus status) OVERRIDE;
   virtual void OnStopSyncingPermanently() OVERRIDE;
   virtual void OnPassphraseRequired(
-      csync::PassphraseRequiredReason reason,
+      syncer::PassphraseRequiredReason reason,
       const sync_pb::EncryptedData& pending_keys) OVERRIDE;
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnEncryptedTypesChanged(
       syncable::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
   virtual void OnEncryptionComplete() OVERRIDE;
   virtual void OnMigrationNeededForTypes(
       syncable::ModelTypeSet types) OVERRIDE;
   virtual void OnExperimentsChanged(
-      const csync::Experiments& experiments) OVERRIDE;
+      const syncer::Experiments& experiments) OVERRIDE;
   virtual void OnActionableError(
-      const csync::SyncProtocolError& error) OVERRIDE;
+      const syncer::SyncProtocolError& error) OVERRIDE;
 
   // Update the last auth error and notify observers of error state.
   void UpdateAuthErrorState(const GoogleServiceAuthError& error);
 
   // Called when a user chooses which data types to sync as part of the sync
   // setup wizard.  |sync_everything| represents whether they chose the
   // "keep everything synced" option; if true, |chosen_types| will be ignored
   // and all data types will be synced.  |sync_everything| means "sync all
   // current and future data types."
   virtual void OnUserChoseDatatypes(bool sync_everything,
@@ skipping 38 matching lines @@
     return unrecoverable_error_location_;
   }
 
   // Returns true if OnPassphraseRequired has been called for any reason.
   virtual bool IsPassphraseRequired() const;
 
   // Returns true if OnPassphraseRequired has been called for decryption and
   // we have an encrypted data type enabled.
   virtual bool IsPassphraseRequiredForDecryption() const;
 
-  csync::PassphraseRequiredReason passphrase_required_reason() const {
+  syncer::PassphraseRequiredReason passphrase_required_reason() const {
     return passphrase_required_reason_;
   }
 
   // Returns a user-friendly string form of last synced time (in minutes).
   virtual string16 GetLastSyncedTimeString() const;
 
   ProfileSyncComponentsFactory* factory() { return factory_.get(); }
 
   // The profile we are syncing for.
   Profile* profile() const { return profile_; }
 
   // Adds/removes an observer. ProfileSyncService does not take ownership of
   // the observer.
   virtual void AddObserver(Observer* observer);
   virtual void RemoveObserver(Observer* observer);
 
   // Returns true if |observer| has already been added as an observer.
   bool HasObserver(Observer* observer) const;
 
   // Returns a weak pointer to the service's JsController.
   // Overrideable for testing purposes.
-  virtual base::WeakPtr<csync::JsController> GetJsController();
+  virtual base::WeakPtr<syncer::JsController> GetJsController();
 
   // Record stats on various events.
   static void SyncEvent(SyncEventCodes code);
 
   // Returns whether sync is enabled.  Sync can be enabled/disabled both
   // at compile time (e.g., on a per-OS basis) or at run time (e.g.,
   // command-line switches).
   static bool IsSyncEnabled();
 
   // Returns whether sync is managed, i.e. controlled by configuration
   // management. If so, the user is not allowed to configure sync.
   bool IsManaged() const;
 
-  // csync::UnrecoverableErrorHandler implementation.
+  // syncer::UnrecoverableErrorHandler implementation.
   virtual void OnUnrecoverableError(
       const tracked_objects::Location& from_here,
       const std::string& message) OVERRIDE;
 
   // Called when a datatype wishes to disable itself due to having hit an
   // unrecoverable error.
   virtual void DisableBrokenDatatype(
       syncable::ModelType type,
       const tracked_objects::Location& from_here,
       std::string message);
 
   // The functions below (until ActivateDataType()) should only be
   // called if sync_initialized() is true.
 
   // TODO(akalin): This is called mostly by ModelAssociators and
   // tests.  Figure out how to pass the handle to the ModelAssociators
   // directly, figure out how to expose this to tests, and remove this
   // function.
-  virtual csync::UserShare* GetUserShare() const;
+  virtual syncer::UserShare* GetUserShare() const;
 
   // TODO(akalin): These two functions are used only by
   // ProfileSyncServiceHarness.  Figure out a different way to expose
   // this info to that class, and remove these functions.
 
-  virtual csync::sessions::SyncSessionSnapshot
+  virtual syncer::sessions::SyncSessionSnapshot
       GetLastSessionSnapshot() const;
 
   // Returns whether or not the underlying sync engine has made any
   // local changes to items that have not yet been synced with the
   // server.
   bool HasUnsyncedItems() const;
 
   // Used by ProfileSyncServiceHarness.  May return NULL.
   browser_sync::BackendMigrator* GetBackendMigratorForTest();
 
   // Get the current routing information for all enabled model types.
   // If a model type is not enabled (that is, if the syncer should not
   // be trying to sync it), it is not in this map.
   //
   // TODO(akalin): This function is used by
   // sync_ui_util::ConstructAboutInformation() and by some test
   // classes.  Figure out a different way to expose this info and
   // remove this function.
   void GetModelSafeRoutingInfo(
-      csync::ModelSafeRoutingInfo* out) const;
+      syncer::ModelSafeRoutingInfo* out) const;
 
   // Overridden by tests.
   // TODO(zea): Remove these and have the dtc's call directly into the SBH.
   virtual void ActivateDataType(
-      syncable::ModelType type, csync::ModelSafeGroup group,
+      syncable::ModelType type, syncer::ModelSafeGroup group,
       browser_sync::ChangeProcessor* change_processor);
   virtual void DeactivateDataType(syncable::ModelType type);
 
   // SyncPrefObserver implementation.
   virtual void OnSyncManagedPrefChange(bool is_sync_managed) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
@@ skipping 13 matching lines @@
   // Gets the set of all data types that could be allowed (the set that
   // should be advertised to the user).  These will typically only change
   // via a command-line option.  See class comment for more on what it means
   // for a datatype to be Registered.
   virtual syncable::ModelTypeSet GetRegisteredDataTypes() const;
 
   // Checks whether the Cryptographer is ready to encrypt and decrypt updates
   // for sensitive data types. Caller must be holding a
   // syncapi::BaseTransaction to ensure thread safety.
   virtual bool IsCryptographerReady(
-      const csync::BaseTransaction* trans) const;
+      const syncer::BaseTransaction* trans) const;
 
   // Returns true if a secondary passphrase is being used. It is not legal
   // to call this method before the backend is initialized.
   virtual bool IsUsingSecondaryPassphrase() const;
 
   // Note about setting passphrases: There are different scenarios under which
   // we might want to apply a passphrase. It could be for first-time encryption,
   // re-encryption, or for decryption by clients that sign in at a later time.
   // In addition, encryption can either be done using a custom passphrase, or by
   // reusing the GAIA password. Depending on what is happening in the system,
@@ skipping 73 matching lines @@
   // Helper to install and configure a data type manager.
   void ConfigureDataTypeManager();
 
   // Starts up the backend sync components.
   void StartUp();
   // Shuts down the backend sync components.
   // |sync_disabled| indicates if syncing is being disabled or not.
   void ShutdownImpl(bool sync_disabled);
 
   // Return SyncCredentials from the TokenService.
-  csync::SyncCredentials GetCredentials();
+  syncer::SyncCredentials GetCredentials();
 
   // Test need to override this to create backends that allow setting up
   // initial conditions, such as populating sync nodes.
   //
   // TODO(akalin): Figure out a better way to do this.  Ideally, we'd
   // construct the backend outside this class and pass it in to the
   // contructor or Initialize().
   virtual void CreateBackend();
 
   const browser_sync::DataTypeController::TypeMap& data_type_controllers() {
@@ skipping 16 matching lines @@
   // user.
   GoogleServiceAuthError last_auth_error_;
 
   // Our asynchronous backend to communicate with sync components living on
   // other threads.
   scoped_ptr<browser_sync::SyncBackendHost> backend_;
 
   // Was the last SYNC_PASSPHRASE_REQUIRED notification sent because it
   // was required for encryption, decryption with a cached passphrase, or
   // because a new passphrase is required?
-  csync::PassphraseRequiredReason passphrase_required_reason_;
+  syncer::PassphraseRequiredReason passphrase_required_reason_;
 
  private:
   enum UnrecoverableErrorReason {
     ERROR_REASON_UNSET,
     ERROR_REASON_SYNCER,
     ERROR_REASON_BACKEND_INIT_FAILURE,
     ERROR_REASON_CONFIGURATION_RETRY,
     ERROR_REASON_CONFIGURATION_FAILURE,
     ERROR_REASON_ACTIONABLE_ERROR,
     ERROR_REASON_LIMIT
@@ skipping 123 matching lines @@
   // Information describing an unrecoverable error.
   UnrecoverableErrorReason unrecoverable_error_reason_;
   std::string unrecoverable_error_message_;
   tracked_objects::Location unrecoverable_error_location_;
 
   // Manages the start and stop of the various data types.
   scoped_ptr<browser_sync::DataTypeManager> data_type_manager_;
 
   ObserverList<Observer> observers_;
 
-  csync::SyncJsController sync_js_controller_;
+  syncer::SyncJsController sync_js_controller_;
 
   content::NotificationRegistrar registrar_;
 
   base::WeakPtrFactory<ProfileSyncService> weak_factory_;
 
   // This allows us to gracefully handle an ABORTED return code from the
   // DataTypeManager in the event that the server informed us to cease and
   // desist syncing immediately.
   bool expect_sync_configuration_aborted_;
 
   // Sometimes we need to temporarily hold on to a passphrase because we don't
   // yet have a backend to send it to.  This happens during initialization as
   // we don't StartUp until we have a valid token, which happens after valid
   // credentials were provided.
   std::string cached_passphrase_;
 
   // The current set of encrypted types.  Always a superset of
-  // csync::Cryptographer::SensitiveTypes().
+  // syncer::Cryptographer::SensitiveTypes().
   syncable::ModelTypeSet encrypted_types_;
 
   // Whether we want to encrypt everything.
   bool encrypt_everything_;
 
   // Whether we're waiting for an attempt to encryption all sync data to
   // complete. We track this at this layer in order to allow the user to cancel
   // if they e.g. don't remember their explicit passphrase.
   bool encryption_pending_;
 
   // If true, we want to automatically start sync signin whenever we have
   // credentials (user doesn't need to go through the startup flow). This is
   // typically enabled on platforms (like ChromeOS) that have their own
   // distinct signin flow.
   const bool auto_start_enabled_;
 
   scoped_ptr<browser_sync::BackendMigrator> migrator_;
 
   // This is the last |SyncProtocolError| we received from the server that had
   // an action set on it.
-  csync::SyncProtocolError last_actionable_error_;
+  syncer::SyncProtocolError last_actionable_error_;
 
   // This is used to show sync errors in the wrench menu.
   scoped_ptr<SyncGlobalError> sync_global_error_;
 
   // keeps track of data types that failed to load.
   FailedDatatypesHandler failed_datatypes_handler_;
 
   scoped_ptr<browser_sync::BackendUnrecoverableErrorHandler>
       backend_unrecoverable_error_handler_;
 
   browser_sync::DataTypeManager::ConfigureStatus configure_status_;
 
   // If |true|, there is setup UI visible so we should not start downloading
   // data types.
   bool setup_in_progress_;
 
   // The set of currently enabled sync experiments.
-  csync::Experiments current_experiments;
+  syncer::Experiments current_experiments;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
-    const csync::SyncProtocolError& error);
+    const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_