[Sync] Rename csync namespace to syncer

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 43 matching lines @@
 static const FilePath::CharType kSyncDataFolderName[] =
     FILE_PATH_LITERAL("Sync Data");
 
 typedef TokenService::TokenAvailableDetails TokenAvailableDetails;
 
 typedef GoogleServiceAuthError AuthError;
 
 namespace browser_sync {
 
 using content::BrowserThread;
-using csync::sessions::SyncSessionSnapshot;
-using csync::SyncCredentials;
+using syncer::sessions::SyncSessionSnapshot;
+using syncer::SyncCredentials;
 
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncers involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 class SyncBackendHost::Core
     : public base::RefCountedThreadSafe<SyncBackendHost::Core>,
-      public csync::SyncManager::Observer {
+      public syncer::SyncManager::Observer {
  public:
   Core(const std::string& name,
        const FilePath& sync_data_folder_path,
        const base::WeakPtr<SyncBackendHost>& backend);
 
   // SyncManager::Observer implementation.  The Core just acts like an air
   // traffic controller here, forwarding incoming messages to appropriate
   // landing threads.
   virtual void OnSyncCycleCompleted(
-      const csync::sessions::SyncSessionSnapshot& snapshot) OVERRIDE;
+      const syncer::sessions::SyncSessionSnapshot& snapshot) OVERRIDE;
   virtual void OnInitializationComplete(
-      const csync::WeakHandle<csync::JsBackend>& js_backend,
+      const syncer::WeakHandle<syncer::JsBackend>& js_backend,
       bool success) OVERRIDE;
   virtual void OnConnectionStatusChange(
-      csync::ConnectionStatus status) OVERRIDE;
+      syncer::ConnectionStatus status) OVERRIDE;
   virtual void OnPassphraseRequired(
-      csync::PassphraseRequiredReason reason,
+      syncer::PassphraseRequiredReason reason,
       const sync_pb::EncryptedData& pending_keys) OVERRIDE;
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnBootstrapTokenUpdated(
       const std::string& bootstrap_token) OVERRIDE;
   virtual void OnStopSyncingPermanently() OVERRIDE;
   virtual void OnUpdatedToken(const std::string& token) OVERRIDE;
   virtual void OnEncryptedTypesChanged(
       syncable::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
   virtual void OnEncryptionComplete() OVERRIDE;
   virtual void OnActionableError(
-      const csync::SyncProtocolError& sync_error) OVERRIDE;
+      const syncer::SyncProtocolError& sync_error) OVERRIDE;
 
   // Note:
   //
   // The Do* methods are the various entry points from our
   // SyncBackendHost.  They are all called on the sync thread to
   // actually perform synchronous (and potentially blocking) syncapi
   // operations.
   //
   // Called to perform initialization of the syncapi on behalf of
   // SyncBackendHost::Initialize.
   void DoInitialize(const DoInitializeOptions& options);
 
   // Called to perform credential update on behalf of
   // SyncBackendHost::UpdateCredentials
-  void DoUpdateCredentials(const csync::SyncCredentials& credentials);
+  void DoUpdateCredentials(const syncer::SyncCredentials& credentials);
 
   // Called when the user disables or enables a sync type.
   void DoUpdateEnabledTypes(const syncable::ModelTypeSet& enabled_types);
 
   // Called to tell the syncapi to start syncing (generally after
   // initialization and authentication).
-  void DoStartSyncing(const csync::ModelSafeRoutingInfo& routing_info);
+  void DoStartSyncing(const syncer::ModelSafeRoutingInfo& routing_info);
 
   // Called to cleanup disabled types.
   void DoRequestCleanupDisabledTypes(
-      const csync::ModelSafeRoutingInfo& routing_info);
+      const syncer::ModelSafeRoutingInfo& routing_info);
 
   // Called to set the passphrase for encryption.
   void DoSetEncryptionPassphrase(const std::string& passphrase,
                                  bool is_explicit);
 
   // Called to decrypt the pending keys.
   void DoSetDecryptionPassphrase(const std::string& passphrase);
 
   // Called to turn on encryption of all sync data as well as
   // reencrypt everything.
@@ skipping 11 matching lines @@
   //    a blocking call). This causes syncapi thread-exit handlers
   //    to run and make use of cached pointers to various components
   //    owned implicitly by us.
   // 3) Destroy this Core. That will delete syncapi components in a
   //    safe order because the thread that was using them has exited
   //    (in step 2).
   void DoStopSyncManagerForShutdown(const base::Closure& closure);
   void DoShutdown(bool stopping_sync);
 
   virtual void DoRequestConfig(
-      const csync::ModelSafeRoutingInfo& routing_info,
+      const syncer::ModelSafeRoutingInfo& routing_info,
       syncable::ModelTypeSet types_to_config,
-      csync::ConfigureReason reason);
+      syncer::ConfigureReason reason);
 
   // Start the configuration mode.  |callback| is called on the sync
   // thread.
   virtual void DoStartConfiguration(const base::Closure& callback);
 
   // Set the base request context to use when making HTTP calls.
   // This method will add a reference to the context to persist it
   // on the IO thread. Must be removed from IO thread.
 
-  csync::SyncManager* sync_manager() { return sync_manager_.get(); }
+  syncer::SyncManager* sync_manager() { return sync_manager_.get(); }
 
   // Delete the sync data folder to cleanup backend data.  Happens the first
   // time sync is enabled for a user (to prevent accidentally reusing old
   // sync databases), as well as shutdown when you're no longer syncing.
   void DeleteSyncDataFolder();
 
   // A callback from the SyncerThread when it is safe to continue config.
   void FinishConfigureDataTypes();
 
  private:
@@ skipping 16 matching lines @@
   // initialization.
   void SaveChanges();
 
   // Name used for debugging.
   const std::string name_;
 
   // Path of the folder that stores the sync data files.
   const FilePath sync_data_folder_path_;
 
   // Our parent SyncBackendHost.
-  csync::WeakHandle<SyncBackendHost> host_;
+  syncer::WeakHandle<SyncBackendHost> host_;
 
   // The loop where all the sync backend operations happen.
   // Non-NULL only between calls to DoInitialize() and DoShutdown().
   MessageLoop* sync_loop_;
 
   // Our parent's registrar (not owned).  Non-NULL only between
   // calls to DoInitialize() and DoShutdown().
   SyncBackendRegistrar* registrar_;
 
   // The timer used to periodically call SaveChanges.
   scoped_ptr<base::RepeatingTimer<Core> > save_changes_timer_;
 
   // Our encryptor, which uses Chrome's encryption functions.
   ChromeEncryptor encryptor_;
 
   // The top-level syncapi entry point.  Lives on the sync thread.
-  scoped_ptr<csync::SyncManager> sync_manager_;
+  scoped_ptr<syncer::SyncManager> sync_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 namespace {
 
 // Parses the given command line for notifier options.
 notifier::NotifierOptions ParseNotifierOptions(
     const CommandLine& command_line,
     const scoped_refptr<net::URLRequestContextGetter>&
@@ skipping 65 matching lines @@
       sync_thread_("Chrome_SyncThread"),
       frontend_loop_(MessageLoop::current()),
       profile_(profile),
       name_("Unknown"),
       initialization_state_(NOT_ATTEMPTED),
       chrome_sync_notification_bridge_(profile_),
       sync_notifier_factory_(
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
-          base::WeakPtr<csync::InvalidationStateTracker>()),
+          base::WeakPtr<syncer::InvalidationStateTracker>()),
       frontend_(NULL) {
 }
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(!registrar_.get());
 }
 
 namespace {
 
@@ skipping 22 matching lines @@
     return user_agent;
   }
 
   user_agent += version_info.Version();
   user_agent += " (" + version_info.LastChange() + ")";
   if (!version_info.IsOfficialBuild())
     user_agent += "-devel";
   return user_agent;
 }
 
-csync::HttpPostProviderFactory* MakeHttpBridgeFactory(
+syncer::HttpPostProviderFactory* MakeHttpBridgeFactory(
     const scoped_refptr<net::URLRequestContextGetter>& getter) {
   return new HttpBridgeFactory(getter, MakeUserAgentForSyncApi());
 }
 
 }  // namespace
 
 void SyncBackendHost::Initialize(
     SyncFrontend* frontend,
-    const csync::WeakHandle<csync::JsEventHandler>& event_handler,
+    const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
     const GURL& sync_service_url,
     syncable::ModelTypeSet initial_types,
     const SyncCredentials& credentials,
     bool delete_sync_data_folder,
-    csync::UnrecoverableErrorHandler* unrecoverable_error_handler,
-    csync::ReportUnrecoverableErrorFunction
+    syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
+    syncer::ReportUnrecoverableErrorFunction
         report_unrecoverable_error_function) {
   if (!sync_thread_.Start())
     return;
 
   frontend_ = frontend;
   DCHECK(frontend);
 
   syncable::ModelTypeSet initial_types_with_nigori(initial_types);
   CHECK(sync_prefs_.get());
   if (sync_prefs_->HasSyncSetupCompleted()) {
     initial_types_with_nigori.Put(syncable::NIGORI);
   }
 
   registrar_.reset(new SyncBackendRegistrar(initial_types_with_nigori,
                                             name_,
                                             profile_,
                                             sync_thread_.message_loop()));
- csync::ModelSafeRoutingInfo routing_info;
-  std::vector<csync::ModelSafeWorker*> workers;
+  syncer::ModelSafeRoutingInfo routing_info;
+  std::vector<syncer::ModelSafeWorker*> workers;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   registrar_->GetWorkers(&workers);
 
   initialization_state_ = CREATING_SYNC_MANAGER;
   InitCore(DoInitializeOptions(
       sync_thread_.message_loop(),
       registrar_.get(),
       routing_info,
       workers,
       &extensions_activity_monitor_,
       event_handler,
       sync_service_url,
       base::Bind(&MakeHttpBridgeFactory,
                  make_scoped_refptr(profile_->GetRequestContext())),
       credentials,
       &chrome_sync_notification_bridge_,
       &sync_notifier_factory_,
       delete_sync_data_folder,
       sync_prefs_->GetEncryptionBootstrapToken(),
-      csync::SyncManager::NON_TEST,
+      syncer::SyncManager::NON_TEST,
       unrecoverable_error_handler,
       report_unrecoverable_error_function));
 }
 
 void SyncBackendHost::UpdateCredentials(const SyncCredentials& credentials) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoUpdateCredentials, core_.get(),
                  credentials));
 }
 
 void SyncBackendHost::StartSyncingWithServer() {
   SDVLOG(1) << "SyncBackendHost::StartSyncingWithServer called.";
 
- csync::ModelSafeRoutingInfo routing_info;
+ syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
 
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoStartSyncing,
                  core_.get(), routing_info));
 }
 
 void SyncBackendHost::SetEncryptionPassphrase(const std::string& passphrase,
                                               bool is_explicit) {
   if (!IsNigoriEnabled()) {
@@ skipping 141 matching lines @@
       stop_thread_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.StopSyncThreadTime",
                       stop_sync_thread_time);
 
   registrar_.reset();
   frontend_ = NULL;
   core_ = NULL;  // Releases reference to core_.
 }
 
 void SyncBackendHost::ConfigureDataTypes(
-    csync::ConfigureReason reason,
+    syncer::ConfigureReason reason,
     syncable::ModelTypeSet types_to_add,
     syncable::ModelTypeSet types_to_remove,
     NigoriState nigori_state,
     base::Callback<void(syncable::ModelTypeSet)> ready_task,
     base::Callback<void()> retry_callback) {
   syncable::ModelTypeSet types_to_add_with_nigori = types_to_add;
   syncable::ModelTypeSet types_to_remove_with_nigori = types_to_remove;
   if (nigori_state == WITH_NIGORI) {
     types_to_add_with_nigori.Put(syncable::NIGORI);
     types_to_remove_with_nigori.Remove(syncable::NIGORI);
@@ skipping 12 matching lines @@
   pending_config_mode_state_->added_types =
       registrar_->ConfigureDataTypes(types_to_add_with_nigori,
                                      types_to_remove_with_nigori);
   pending_config_mode_state_->reason = reason;
   pending_config_mode_state_->retry_callback = retry_callback;
 
   // Cleanup disabled types before starting configuration so that
   // callers can assume that the data types are cleaned up once
   // configuration is done.
   if (!types_to_remove_with_nigori.Empty()) {
-   csync::ModelSafeRoutingInfo routing_info;
+   syncer::ModelSafeRoutingInfo routing_info;
     registrar_->GetModelSafeRoutingInfo(&routing_info);
     sync_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&SyncBackendHost::Core::DoRequestCleanupDisabledTypes,
                    core_.get(),
                    routing_info));
   }
 
   StartConfiguration(
       base::Bind(&SyncBackendHost::Core::FinishConfigureDataTypes,
                  core_.get()));
 }
 
 void SyncBackendHost::StartConfiguration(const base::Closure& callback) {
   // Put syncer in the config mode. DTM will put us in normal mode once it is
   // done. This is to ensure we dont do a normal sync when we are doing model
   // association.
   sync_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &SyncBackendHost::Core::DoStartConfiguration, core_.get(), callback));
 }
 
 void SyncBackendHost::EnableEncryptEverything() {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
      base::Bind(&SyncBackendHost::Core::DoEnableEncryptEverything,
                 core_.get()));
 }
 
 void SyncBackendHost::ActivateDataType(
-    syncable::ModelType type, csync::ModelSafeGroup group,
+    syncable::ModelType type, syncer::ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
 
 void SyncBackendHost::DeactivateDataType(syncable::ModelType type) {
   registrar_->DeactivateDataType(type);
 }
 
-csync::UserShare* SyncBackendHost::GetUserShare() const {
+syncer::UserShare* SyncBackendHost::GetUserShare() const {
   DCHECK(initialized());
   return core_->sync_manager()->GetUserShare();
 }
 
 SyncBackendHost::Status SyncBackendHost::GetDetailedStatus() {
   DCHECK(initialized());
   return core_->sync_manager()->GetDetailedStatus();
 }
 
 SyncSessionSnapshot SyncBackendHost::GetLastSessionSnapshot() const {
@@ skipping 12 matching lines @@
 bool SyncBackendHost::IsUsingExplicitPassphrase() {
   // This should only be called once the nigori node has been downloaded, as
   // otherwise we have no idea what kind of passphrase we are using. This will
   // NOTREACH in sync_manager and return false if we fail to load the nigori
   // node.
   return IsNigoriEnabled() &&
       core_->sync_manager()->IsUsingExplicitPassphrase();
 }
 
 bool SyncBackendHost::IsCryptographerReady(
-    const csync::BaseTransaction* trans) const {
+    const syncer::BaseTransaction* trans) const {
   return initialized() && trans->GetCryptographer()->is_ready();
 }
 
 void SyncBackendHost::GetModelSafeRoutingInfo(
-   csync::ModelSafeRoutingInfo* out) const {
+   syncer::ModelSafeRoutingInfo* out) const {
   if (initialized()) {
     CHECK(registrar_.get());
     registrar_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
 }
 
 void SyncBackendHost::InitCore(const DoInitializeOptions& options) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
@@ skipping 76 matching lines @@
   // In the case of additions, on the next sync cycle, the syncer should
   // notice that the routing info has changed and start the process of
   // downloading updates for newly added data types.  Once this is
   // complete, the configure_state_.ready_task_ is run via an
   // OnInitializationComplete notification.
 
   SDVLOG(1) << "Syncer in config mode. SBH executing "
             << "FinishConfigureDataTypesOnFrontendLoop";
 
 
- csync::ModelSafeRoutingInfo routing_info;
+ syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   const syncable::ModelTypeSet enabled_types =
       GetRoutingInfoTypes(routing_info);
 
   // Update |chrome_sync_notification_bridge_|'s enabled types here as it has
   // to happen on the UI thread.
   chrome_sync_notification_bridge_.UpdateEnabledTypes(enabled_types);
 
   if (pending_config_mode_state_->added_types.Empty() &&
       !core_->sync_manager()->InitialSyncEndedTypes().HasAll(enabled_types)) {
 
     // TODO(tim): Log / UMA / count this somehow?
     // Add only the types with empty progress markers. Note: it is possible
     // that some types have their initial_sync_ended be false but with non
     // empty progress marker. Which is ok as the rest of the changes would
     // be downloaded on a regular nudge and initial_sync_ended should be set
     // to true. However this is a very corner case. So it is not explicitly
     // handled.
     pending_config_mode_state_->added_types =
-        csync::GetTypesWithEmptyProgressMarkerToken(enabled_types,
+        syncer::GetTypesWithEmptyProgressMarkerToken(enabled_types,
                                                        GetUserShare());
   }
 
   // If we've added types, we always want to request a nudge/config (even if
   // the initial sync is ended), in case we could not decrypt the data.
   if (pending_config_mode_state_->added_types.Empty()) {
     SDVLOG(1) << "No new types added; calling ready_task directly";
     // No new types - just notify the caller that the types are available.
     const syncable::ModelTypeSet failed_configuration_types;
     pending_config_mode_state_->ready_task.Run(failed_configuration_types);
   } else {
     pending_download_state_.reset(pending_config_mode_state_.release());
 
     // Always configure nigori if it's enabled.
     syncable::ModelTypeSet types_to_config =
         pending_download_state_->added_types;
     if (IsNigoriEnabled()) {
       // Note: Nigori is the only type that gets added with a nonempty
       // progress marker during config. If the server returns a migration
       // error then we will go into unrecoverable error. We dont handle it
       // explicitly because server might help us out here by not sending a
       // migraiton error for nigori during config.
       types_to_config.Put(syncable::NIGORI);
     }
     SDVLOG(1) << "Types "
               << syncable::ModelTypeSetToString(types_to_config)
               << " added; calling DoRequestConfig";
-   csync::ModelSafeRoutingInfo routing_info;
+   syncer::ModelSafeRoutingInfo routing_info;
     registrar_->GetModelSafeRoutingInfo(&routing_info);
     sync_thread_.message_loop()->PostTask(FROM_HERE,
          base::Bind(&SyncBackendHost::Core::DoRequestConfig,
                     core_.get(),
                     routing_info,
                     types_to_config,
                     pending_download_state_->reason));
   }
 
   pending_config_mode_state_.reset();
 
   // Notify SyncManager (especially the notification listener) about new types.
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoUpdateEnabledTypes, core_.get(),
                  enabled_types));
 }
 
 bool SyncBackendHost::IsDownloadingNigoriForTest() const {
   return initialization_state_ == DOWNLOADING_NIGORI;
 }
 
 SyncBackendHost::DoInitializeOptions::DoInitializeOptions(
     MessageLoop* sync_loop,
     SyncBackendRegistrar* registrar,
-    const csync::ModelSafeRoutingInfo& routing_info,
-    const std::vector<csync::ModelSafeWorker*>& workers,
-    csync::ExtensionsActivityMonitor* extensions_activity_monitor,
-    const csync::WeakHandle<csync::JsEventHandler>& event_handler,
+    const syncer::ModelSafeRoutingInfo& routing_info,
+    const std::vector<syncer::ModelSafeWorker*>& workers,
+    syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
+    const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
     const GURL& service_url,
     MakeHttpBridgeFactoryFn make_http_bridge_factory_fn,
-    const csync::SyncCredentials& credentials,
+    const syncer::SyncCredentials& credentials,
     ChromeSyncNotificationBridge* chrome_sync_notification_bridge,
-    csync::SyncNotifierFactory* sync_notifier_factory,
+    syncer::SyncNotifierFactory* sync_notifier_factory,
     bool delete_sync_data_folder,
     const std::string& restored_key_for_bootstrapping,
-    csync::SyncManager::TestingMode testing_mode,
-    csync::UnrecoverableErrorHandler* unrecoverable_error_handler,
-    csync::ReportUnrecoverableErrorFunction
+    syncer::SyncManager::TestingMode testing_mode,
+    syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
+    syncer::ReportUnrecoverableErrorFunction
         report_unrecoverable_error_function)
     : sync_loop(sync_loop),
       registrar(registrar),
       routing_info(routing_info),
       workers(workers),
       extensions_activity_monitor(extensions_activity_monitor),
       event_handler(event_handler),
       service_url(service_url),
       make_http_bridge_factory_fn(make_http_bridge_factory_fn),
       credentials(credentials),
@@ skipping 20 matching lines @@
   DCHECK(backend.get());
 }
 
 SyncBackendHost::Core::~Core() {
   DCHECK(!sync_manager_.get());
   DCHECK(!sync_loop_);
 }
 
 SyncBackendHost::PendingConfigureDataTypesState::
 PendingConfigureDataTypesState()
-    : reason(csync::CONFIGURE_REASON_UNKNOWN),
+    : reason(syncer::CONFIGURE_REASON_UNKNOWN),
       retry_in_progress(false) {}
 
 SyncBackendHost::PendingConfigureDataTypesState::
 ~PendingConfigureDataTypesState() {}
 
 void SyncBackendHost::Core::OnSyncCycleCompleted(
     const SyncSessionSnapshot& snapshot) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleSyncCycleCompletedOnFrontendLoop,
       snapshot);
 }
 
 
 void SyncBackendHost::Core::OnInitializationComplete(
-    const csync::WeakHandle<csync::JsBackend>& js_backend,
+    const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     bool success) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleInitializationCompletedOnFrontendLoop,
       js_backend, success);
 
   if (success) {
     // Initialization is complete, so we can schedule recurring SaveChanges.
     sync_loop_->PostTask(FROM_HERE,
                          base::Bind(&Core::StartSavingChanges, this));
   }
 }
 
 void SyncBackendHost::Core::OnConnectionStatusChange(
-    csync::ConnectionStatus status) {
+    syncer::ConnectionStatus status) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleConnectionStatusChangeOnFrontendLoop, status);
 }
 
 void SyncBackendHost::Core::OnPassphraseRequired(
-    csync::PassphraseRequiredReason reason,
+    syncer::PassphraseRequiredReason reason,
     const sync_pb::EncryptedData& pending_keys) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyPassphraseRequired, reason, pending_keys);
 }
 
 void SyncBackendHost::Core::OnPassphraseAccepted() {
@@ skipping 50 matching lines @@
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // NOTE: We're in a transaction.
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyEncryptionComplete);
 }
 
 void SyncBackendHost::Core::OnActionableError(
-    const csync::SyncProtocolError& sync_error) {
+    const syncer::SyncProtocolError& sync_error) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleActionableErrorEventOnFrontendLoop,
       sync_error);
 }
 
 void SyncBackendHost::Core::DoInitialize(const DoInitializeOptions& options) {
   DCHECK(!sync_loop_);
   sync_loop_ = options.sync_loop;
   DCHECK(sync_loop_);
 
   // Blow away the partial or corrupt sync data folder before doing any more
   // initialization, if necessary.
   if (options.delete_sync_data_folder) {
     DeleteSyncDataFolder();
   }
 
   // Make sure that the directory exists before initializing the backend.
   // If it already exists, this will do no harm.
   bool success = file_util::CreateDirectory(sync_data_folder_path_);
   DCHECK(success);
 
   DCHECK(!registrar_);
   registrar_ = options.registrar;
   DCHECK(registrar_);
 
-  sync_manager_.reset(new csync::SyncManager(name_));
+  sync_manager_.reset(new syncer::SyncManager(name_));
   sync_manager_->AddObserver(this);
   success = sync_manager_->Init(
       sync_data_folder_path_,
       options.event_handler,
       options.service_url.host() + options.service_url.path(),
       options.service_url.EffectiveIntPort(),
       options.service_url.SchemeIsSecure(),
       BrowserThread::GetBlockingPool(),
       options.make_http_bridge_factory_fn.Run(),
       options.routing_info,
@@ skipping 29 matching lines @@
   sync_manager_->UpdateCredentials(credentials);
 }
 
 void SyncBackendHost::Core::DoUpdateEnabledTypes(
     const syncable::ModelTypeSet& enabled_types) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->UpdateEnabledTypes(enabled_types);
 }
 
 void SyncBackendHost::Core::DoStartSyncing(
-    const csync::ModelSafeRoutingInfo& routing_info) {
+    const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartSyncingNormally(routing_info);
 }
 
 void SyncBackendHost::Core::DoRequestCleanupDisabledTypes(
-    const csync::ModelSafeRoutingInfo& routing_info) {
+    const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->RequestCleanupDisabledTypes(routing_info);
 }
 
 void SyncBackendHost::Core::DoSetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->SetEncryptionPassphrase(passphrase, is_explicit);
 }
@@ skipping 36 matching lines @@
 
   if (sync_disabled)
     DeleteSyncDataFolder();
 
   sync_loop_ = NULL;
 
   host_.Reset();
 }
 
 void SyncBackendHost::Core::DoRequestConfig(
-    const csync::ModelSafeRoutingInfo& routing_info,
+    const syncer::ModelSafeRoutingInfo& routing_info,
     syncable::ModelTypeSet types_to_config,
-    csync::ConfigureReason reason) {
+    syncer::ConfigureReason reason) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->RequestConfig(routing_info, types_to_config, reason);
 }
 
 void SyncBackendHost::Core::DoStartConfiguration(
     const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartConfigurationMode(callback);
 }
 
@@ skipping 24 matching lines @@
       this, &Core::SaveChanges);
 }
 
 void SyncBackendHost::Core::SaveChanges() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->SaveChanges();
 }
 
 void SyncBackendHost::AddExperimentalTypes() {
   CHECK(initialized());
-  csync::Experiments experiments;
+  syncer::Experiments experiments;
   if (core_->sync_manager()->ReceivedExperiment(&experiments))
     frontend_->OnExperimentsChanged(experiments);
 }
 
 void SyncBackendHost::OnNigoriDownloadRetry() {
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   if (!frontend_)
     return;
 
   frontend_->OnSyncConfigureRetry();
 }
 
 void SyncBackendHost::HandleInitializationCompletedOnFrontendLoop(
-    const csync::WeakHandle<csync::JsBackend>& js_backend, bool success) {
+    const syncer::WeakHandle<syncer::JsBackend>& js_backend, bool success) {
   DCHECK_NE(NOT_ATTEMPTED, initialization_state_);
   if (!frontend_)
     return;
 
   // We've at least created the sync manager at this point, but if that is all
   // we've done we're just beginning the initialization process.
   if (initialization_state_ == CREATING_SYNC_MANAGER)
     initialization_state_ = NOT_INITIALIZED;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   if (!success) {
     initialization_state_ = NOT_INITIALIZED;
     frontend_->OnBackendInitialized(
-        csync::WeakHandle<csync::JsBackend>(), false);
+        syncer::WeakHandle<syncer::JsBackend>(), false);
     return;
   }
 
   // If setup has completed, start off in DOWNLOADING_NIGORI so that
   // we start off by refreshing nigori.
   CHECK(sync_prefs_.get());
   if (sync_prefs_->HasSyncSetupCompleted() &&
       initialization_state_ < DOWNLOADING_NIGORI) {
     initialization_state_ = DOWNLOADING_NIGORI;
   }
 
   // Run initialization state machine.
   switch (initialization_state_) {
     case NOT_INITIALIZED:
       initialization_state_ = DOWNLOADING_NIGORI;
       ConfigureDataTypes(
-          csync::CONFIGURE_REASON_NEW_CLIENT,
+          syncer::CONFIGURE_REASON_NEW_CLIENT,
           syncable::ModelTypeSet(),
           syncable::ModelTypeSet(),
           WITH_NIGORI,
           // Calls back into this function.
           base::Bind(
               &SyncBackendHost::
                   HandleNigoriConfigurationCompletedOnFrontendLoop,
               weak_ptr_factory_.GetWeakPtr(), js_backend),
           base::Bind(&SyncBackendHost::OnNigoriDownloadRetry,
                      weak_ptr_factory_.GetWeakPtr()));
@@ skipping 21 matching lines @@
   }
 }
 
 void SyncBackendHost::PersistEncryptionBootstrapToken(
     const std::string& token) {
   CHECK(sync_prefs_.get());
   sync_prefs_->SetEncryptionBootstrapToken(token);
 }
 
 void SyncBackendHost::HandleActionableErrorEventOnFrontendLoop(
-    const csync::SyncProtocolError& sync_error) {
+    const syncer::SyncProtocolError& sync_error) {
   if (!frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   frontend_->OnActionableError(sync_error);
 }
 
 bool SyncBackendHost::CheckPassphraseAgainstCachedPendingKeys(
     const std::string& passphrase) const {
   DCHECK(cached_pending_keys_.has_blob());
   DCHECK(!passphrase.empty());
-  csync::Nigori nigori;
+  syncer::Nigori nigori;
   nigori.InitByDerivation("localhost", "dummy", passphrase);
   std::string plaintext;
   bool result = nigori.Decrypt(cached_pending_keys_.blob(), &plaintext);
   return result;
 }
 
 void SyncBackendHost::NotifyPassphraseRequired(
-    csync::PassphraseRequiredReason reason,
+    syncer::PassphraseRequiredReason reason,
     sync_pb::EncryptedData pending_keys) {
   if (!frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
   // Update our cache of the cryptographer's pending keys.
   cached_pending_keys_ = pending_keys;
 
   frontend_->OnPassphraseRequired(reason, pending_keys);
@@ skipping 38 matching lines @@
   frontend_->OnEncryptionComplete();
 }
 
 void SyncBackendHost::HandleStopSyncingPermanentlyOnFrontendLoop() {
   if (!frontend_)
     return;
   frontend_->OnStopSyncingPermanently();
 }
 
 void SyncBackendHost::HandleConnectionStatusChangeOnFrontendLoop(
-    csync::ConnectionStatus status) {
+    syncer::ConnectionStatus status) {
   if (!frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
   frontend_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHost::HandleNigoriConfigurationCompletedOnFrontendLoop(
-    const csync::WeakHandle<csync::JsBackend>& js_backend,
+    const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncable::ModelTypeSet failed_configuration_types) {
   HandleInitializationCompletedOnFrontendLoop(
       js_backend, failed_configuration_types.Empty());
 }
 
 namespace {
 
 // Needed because MessageLoop::PostTask is overloaded.
 void PostClosure(MessageLoop* message_loop,
                  const tracked_objects::Location& from_here,
@@ skipping 12 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshNigori,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync