[Sync] Rename csync namespace to syncer

chrome/browser/sync/profile_sync_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/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 50 matching lines @@
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
 #include "sync/util/cryptographer.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::SyncBackendHost;
-using csync::JsBackend;
-using csync::JsController;
-using csync::JsEventDetails;
-using csync::JsEventHandler;
-using csync::ModelSafeRoutingInfo;
-using csync::SyncCredentials;
-using csync::SyncProtocolError;
-using csync::WeakHandle;
 using syncable::ModelType;
 using syncable::ModelTypeSet;
+using syncer::JsBackend;
+using syncer::JsController;
+using syncer::JsEventDetails;
+using syncer::JsEventHandler;
+using syncer::ModelSafeRoutingInfo;
+using syncer::SyncCredentials;
+using syncer::SyncProtocolError;
+using syncer::WeakHandle;
 
 typedef GoogleServiceAuthError AuthError;
 
 const char* ProfileSyncService::kSyncServerUrl =
     "https://clients4.google.com/chrome-sync";
 
 const char* ProfileSyncService::kDevServerUrl =
     "https://clients4.google.com/chrome-sync/dev";
 
 static const int kSyncClearDataTimeoutInSeconds = 60;  // 1 minute.
@@ skipping 10 matching lines @@
 // Helper to check if the given token service is relevant for sync.
 static bool IsTokenServiceRelevant(const std::string& service) {
   for (int i = 0; i < kRelevantTokenServicesCount; ++i) {
     if (service == kRelevantTokenServices[i])
       return true;
   }
   return false;
 }
 
 bool ShouldShowActionOnUI(
-    const csync::SyncProtocolError& error) {
-  return (error.action != csync::UNKNOWN_ACTION &&
-          error.action != csync::DISABLE_SYNC_ON_CLIENT);
+    const syncer::SyncProtocolError& error) {
+  return (error.action != syncer::UNKNOWN_ACTION &&
+          error.action != syncer::DISABLE_SYNC_ON_CLIENT);
 }
 
 ProfileSyncService::ProfileSyncService(ProfileSyncComponentsFactory* factory,
                                        Profile* profile,
                                        SigninManager* signin_manager,
                                        StartBehavior start_behavior)
     : last_auth_error_(AuthError::None()),
-      passphrase_required_reason_(csync::REASON_PASSPHRASE_NOT_REQUIRED),
+      passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       factory_(factory),
       profile_(profile),
       // |profile| may be NULL in unit tests.
       sync_prefs_(profile_ ? profile_->GetPrefs() : NULL),
       invalidator_storage_(profile_ ? profile_->GetPrefs(): NULL),
       sync_service_url_(kDevServerUrl),
       backend_initialized_(false),
       is_auth_in_progress_(false),
       signin_(signin_manager),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       expect_sync_configuration_aborted_(false),
-      encrypted_types_(csync::Cryptographer::SensitiveTypes()),
+      encrypted_types_(syncer::Cryptographer::SensitiveTypes()),
       encrypt_everything_(false),
       encryption_pending_(false),
       auto_start_enabled_(start_behavior == AUTO_START),
       failed_datatypes_handler_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       configure_status_(DataTypeManager::UNKNOWN),
       setup_in_progress_(false) {
 #if defined(OS_ANDROID)
   chrome::VersionInfo version_info;
   if (version_info.IsOfficialBuild()) {
     sync_service_url_ = GURL(kSyncServerUrl);
@@ skipping 327 matching lines @@
     registrar_.Remove(
         this,
         chrome::NOTIFICATION_SYNC_CONFIGURE_BLOCKED,
         content::Source<DataTypeManager>(data_type_manager_.get()));
     data_type_manager_.reset();
   }
 
   // Shutdown the migrator before the backend to ensure it doesn't pull a null
   // snapshot.
   migrator_.reset();
-  sync_js_controller_.AttachJsBackend(WeakHandle<csync::JsBackend>());
+  sync_js_controller_.AttachJsBackend(WeakHandle<syncer::JsBackend>());
 
   // Move aside the backend so nobody else tries to use it while we are
   // shutting it down.
   scoped_ptr<SyncBackendHost> doomed_backend(backend_.release());
   if (doomed_backend.get()) {
     doomed_backend->Shutdown(sync_disabled);
 
     doomed_backend.reset();
   }
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   weak_factory_.InvalidateWeakPtrs();
 
   // Clear various flags.
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
   cached_passphrase_.clear();
   encryption_pending_ = false;
   encrypt_everything_ = false;
-  encrypted_types_ = csync::Cryptographer::SensitiveTypes();
-  passphrase_required_reason_ = csync::REASON_PASSPHRASE_NOT_REQUIRED;
+  encrypted_types_ = syncer::Cryptographer::SensitiveTypes();
+  passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
   last_auth_error_ = GoogleServiceAuthError::None();
 
   if (sync_global_error_.get()) {
     GlobalErrorServiceFactory::GetForProfile(profile_)->RemoveGlobalError(
         sync_global_error_.get());
     RemoveObserver(sync_global_error_.get());
     sync_global_error_.reset(NULL);
   }
 }
 
@@ skipping 63 matching lines @@
   if (data_type_controllers_.count(data_type) > 0)
     return;
   NOTREACHED();
 }
 
 // An invariant has been violated.  Transition to an error state where we try
 // to do as little work as possible, to avoid further corruption or crashes.
 void ProfileSyncService::OnUnrecoverableError(
     const tracked_objects::Location& from_here,
     const std::string& message) {
-  // Unrecoverable errors that arrive via the csync::UnrecoverableErrorHandler
+  // Unrecoverable errors that arrive via the syncer::UnrecoverableErrorHandler
   // interface are assumed to originate within the syncer.
   unrecoverable_error_reason_ = ERROR_REASON_SYNCER;
   OnUnrecoverableErrorImpl(from_here, message, true);
 }
 
 void ProfileSyncService::OnUnrecoverableErrorImpl(
     const tracked_objects::Location& from_here,
     const std::string& message,
     bool delete_sync_database) {
   DCHECK(HasUnrecoverableError());
@@ skipping 17 matching lines @@
 }
 
 void ProfileSyncService::DisableBrokenDatatype(
     syncable::ModelType type,
     const tracked_objects::Location& from_here,
     std::string message) {
   // First deactivate the type so that no further server changes are
   // passed onto the change processor.
   DeactivateDataType(type);
 
-  csync::SyncError error(from_here, message, type);
+  syncer::SyncError error(from_here, message, type);
 
-  std::list<csync::SyncError> errors;
+  std::list<syncer::SyncError> errors;
   errors.push_back(error);
 
   // Update this before posting a task. So if a configure happens before
   // the task that we are going to post, this type would still be disabled.
   failed_datatypes_handler_.UpdateFailedDatatypes(errors,
       FailedDatatypesHandler::RUNTIME);
 
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ProfileSyncService::ReconfigureDatatypeManager,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ProfileSyncService::OnBackendInitialized(
-    const csync::WeakHandle<csync::JsBackend>& js_backend, bool success) {
+    const syncer::WeakHandle<syncer::JsBackend>& js_backend, bool success) {
   if (!HasSyncSetupCompleted()) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
   }
 
   if (!success) {
     // Something went unexpectedly wrong.  Play it safe: stop syncing at once
     // and surface error UI to alert the user sync has stopped.
     // Keep the directory around for now so that on restart we will retry
@@ skipping 48 matching lines @@
     // rely on the local clock, which may be off significantly.
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&browser_sync::SessionModelAssociator::DeleteStaleSessions,
                    GetSessionModelAssociator()->AsWeakPtr()));
   }
   DVLOG(2) << "Notifying observers sync cycle completed";
   NotifyObservers();
 }
 
 void ProfileSyncService::OnExperimentsChanged(
-    const csync::Experiments& experiments) {
+    const syncer::Experiments& experiments) {
   if (current_experiments.Matches(experiments))
     return;
 
   // If this is a first time sync for a client, this will be called before
   // OnBackendInitialized() to ensure the new datatypes are available at sync
   // setup. As a result, the migrator won't exist yet. This is fine because for
   // first time sync cases we're only concerned with making the datatype
   // available.
   if (migrator_.get() &&
       migrator_->state() != browser_sync::BackendMigrator::IDLE) {
@@ skipping 63 matching lines @@
   is_auth_in_progress_ = false;
   last_auth_error_ = error;
 
   // Fan the notification out to interested UI-thread components.
   NotifyObservers();
 }
 
 namespace {
 
 GoogleServiceAuthError ConnectionStatusToAuthError(
-    csync::ConnectionStatus status) {
+    syncer::ConnectionStatus status) {
   switch (status) {
-    case csync::CONNECTION_OK:
+    case syncer::CONNECTION_OK:
       return GoogleServiceAuthError::None();
       break;
-    case csync::CONNECTION_AUTH_ERROR:
+    case syncer::CONNECTION_AUTH_ERROR:
       return GoogleServiceAuthError(
           GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
       break;
-    case csync::CONNECTION_SERVER_ERROR:
+    case syncer::CONNECTION_SERVER_ERROR:
       return GoogleServiceAuthError(GoogleServiceAuthError::CONNECTION_FAILED);
       break;
     default:
       NOTREACHED();
       return GoogleServiceAuthError(GoogleServiceAuthError::CONNECTION_FAILED);
   }
 }
 
 }  // namespace
 
 void ProfileSyncService::OnConnectionStatusChange(
-    csync::ConnectionStatus status) {
+    syncer::ConnectionStatus status) {
   UpdateAuthErrorState(ConnectionStatusToAuthError(status));
 }
 
 void ProfileSyncService::OnStopSyncingPermanently() {
   UpdateAuthErrorState(
       GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE));
   sync_prefs_.SetStartSuppressed(true);
   DisableForUser();
 }
 
 void ProfileSyncService::OnPassphraseRequired(
-    csync::PassphraseRequiredReason reason,
+    syncer::PassphraseRequiredReason reason,
     const sync_pb::EncryptedData& pending_keys) {
   DCHECK(backend_.get());
   DCHECK(backend_->IsNigoriEnabled());
 
   // TODO(lipalani) : add this check to other locations as well.
   if (HasUnrecoverableError()) {
     // When unrecoverable error is detected we post a task to shutdown the
     // backend. The task might not have executed yet.
     return;
   }
 
   DVLOG(1) << "Passphrase required with reason: "
-           << csync::PassphraseRequiredReasonToString(reason);
+           << syncer::PassphraseRequiredReasonToString(reason);
   passphrase_required_reason_ = reason;
 
   // Notify observers that the passphrase status may have changed.
   NotifyObservers();
 }
 
 void ProfileSyncService::OnPassphraseAccepted() {
   DVLOG(1) << "Received OnPassphraseAccepted.";
   // If we are not using an explicit passphrase, and we have a cache of the gaia
   // password, use it for encryption at this point.
   DCHECK(cached_passphrase_.empty()) <<
       "Passphrase no longer required but there is still a cached passphrase";
 
   // Reset passphrase_required_reason_ since we know we no longer require the
   // passphrase. We do this here rather than down in ResolvePassphraseRequired()
   // because that can be called by OnPassphraseRequired() if no encrypted data
   // types are enabled, and we don't want to clobber the true passphrase error.
-  passphrase_required_reason_ = csync::REASON_PASSPHRASE_NOT_REQUIRED;
+  passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
 
   // Make sure the data types that depend on the passphrase are started at
   // this time.
   const syncable::ModelTypeSet types = GetPreferredDataTypes();
 
   if (data_type_manager_.get()) {
     // Unblock the data type manager if necessary.
     data_type_manager_->Configure(types,
-                                  csync::CONFIGURE_REASON_RECONFIGURATION);
+                                  syncer::CONFIGURE_REASON_RECONFIGURATION);
   }
 
   NotifyObservers();
 }
 
 void ProfileSyncService::OnEncryptedTypesChanged(
     syncable::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   encrypted_types_ = encrypted_types;
   encrypt_everything_ = encrypt_everything;
@@ skipping 20 matching lines @@
   DCHECK(data_type_manager_.get());
 
   // Migrator must be valid, because we don't sync until it is created and this
   // callback originates from a sync cycle.
   migrator_->MigrateTypes(types);
 }
 
 void ProfileSyncService::OnActionableError(const SyncProtocolError& error) {
   last_actionable_error_ = error;
   DCHECK_NE(last_actionable_error_.action,
-            csync::UNKNOWN_ACTION);
+            syncer::UNKNOWN_ACTION);
   switch (error.action) {
-    case csync::UPGRADE_CLIENT:
-    case csync::CLEAR_USER_DATA_AND_RESYNC:
-    case csync::ENABLE_SYNC_ON_ACCOUNT:
-    case csync::STOP_AND_RESTART_SYNC:
+    case syncer::UPGRADE_CLIENT:
+    case syncer::CLEAR_USER_DATA_AND_RESYNC:
+    case syncer::ENABLE_SYNC_ON_ACCOUNT:
+    case syncer::STOP_AND_RESTART_SYNC:
       // TODO(lipalani) : if setup in progress we want to display these
       // actions in the popup. The current experience might not be optimal for
       // the user. We just dismiss the dialog.
       if (setup_in_progress_) {
         OnStopSyncingPermanently();
         expect_sync_configuration_aborted_ = true;
       }
       // Trigger an unrecoverable error to stop syncing.
       OnInternalUnrecoverableError(FROM_HERE,
                                    last_actionable_error_.error_description,
                                    true,
                                    ERROR_REASON_ACTIONABLE_ERROR);
       break;
-    case csync::DISABLE_SYNC_ON_CLIENT:
+    case syncer::DISABLE_SYNC_ON_CLIENT:
       OnStopSyncingPermanently();
       break;
     default:
       NOTREACHED();
   }
   NotifyObservers();
 }
 
 std::string ProfileSyncService::QuerySyncStatusSummary() {
   if (HasUnrecoverableError()) {
@@ skipping 47 matching lines @@
 bool ProfileSyncService::waiting_for_auth() const {
   return is_auth_in_progress_;
 }
 
 bool ProfileSyncService::HasUnrecoverableError() const {
   return unrecoverable_error_reason_ != ERROR_REASON_UNSET;
 }
 
 bool ProfileSyncService::IsPassphraseRequired() const {
   return passphrase_required_reason_ !=
-      csync::REASON_PASSPHRASE_NOT_REQUIRED;
+      syncer::REASON_PASSPHRASE_NOT_REQUIRED;
 }
 
 // TODO(zea): Rename this IsPassphraseNeededFromUI and ensure it's used
 // appropriately (see http://crbug.com/91379).
 bool ProfileSyncService::IsPassphraseRequiredForDecryption() const {
   // If there is an encrypted datatype enabled and we don't have the proper
   // passphrase, we must prompt the user for a passphrase. The only way for the
   // user to avoid entering their passphrase is to disable the encrypted types.
   return IsEncryptedDatatypeEnabled() && IsPassphraseRequired();
 }
@@ skipping 64 matching lines @@
             browser_sync::user_selectable_type::SELECTABLE_DATATYPE_COUNT + 1);
       }
     }
   }
 }
 
 #if defined(OS_CHROMEOS)
 void ProfileSyncService::RefreshSpareBootstrapToken(
     const std::string& passphrase) {
   browser_sync::ChromeEncryptor encryptor;
-  csync::Cryptographer temp_cryptographer(&encryptor);
+  syncer::Cryptographer temp_cryptographer(&encryptor);
   // The first 2 params (hostname and username) doesn't have any effect here.
-  csync::KeyParams key_params = {"localhost", "dummy", passphrase};
+  syncer::KeyParams key_params = {"localhost", "dummy", passphrase};
 
   std::string bootstrap_token;
   if (!temp_cryptographer.AddKey(key_params)) {
     NOTREACHED() << "Failed to add key to cryptographer.";
   }
   temp_cryptographer.GetBootstrapToken(&bootstrap_token);
   sync_prefs_.SetSpareBootstrapToken(bootstrap_token);
 }
 #endif
 
@@ skipping 46 matching lines @@
     registered_types.Put(it->first);
   }
   return registered_types;
 }
 
 bool ProfileSyncService::IsUsingSecondaryPassphrase() const {
   return backend_->IsUsingExplicitPassphrase();
 }
 
 bool ProfileSyncService::IsCryptographerReady(
-    const csync::BaseTransaction* trans) const {
+    const syncer::BaseTransaction* trans) const {
   return backend_.get() && backend_->IsCryptographerReady(trans);
 }
 
 SyncBackendHost* ProfileSyncService::GetBackendForTest() {
   // We don't check |backend_initialized_|; we assume the test class
   // knows what it's doing.
   return backend_.get();
 }
 
 void ProfileSyncService::ConfigureDataTypeManager() {
@@ skipping 24 matching lines @@
 
   const syncable::ModelTypeSet types = GetPreferredDataTypes();
   if (IsPassphraseRequiredForDecryption()) {
     // We need a passphrase still. We don't bother to attempt to configure
     // until we receive an OnPassphraseAccepted (which triggers a configure).
     DVLOG(1) << "ProfileSyncService::ConfigureDataTypeManager bailing out "
              << "because a passphrase required";
     NotifyObservers();
     return;
   }
-  csync::ConfigureReason reason = csync::CONFIGURE_REASON_UNKNOWN;
+  syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN;
   if (!HasSyncSetupCompleted()) {
-    reason = csync::CONFIGURE_REASON_NEW_CLIENT;
+    reason = syncer::CONFIGURE_REASON_NEW_CLIENT;
   } else if (restart == false ||
-             csync::InitialSyncEndedForTypes(types, GetUserShare())) {
-    reason = csync::CONFIGURE_REASON_RECONFIGURATION;
+             syncer::InitialSyncEndedForTypes(types, GetUserShare())) {
+    reason = syncer::CONFIGURE_REASON_RECONFIGURATION;
   } else {
     DCHECK(restart);
-    reason = csync::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE;
+    reason = syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE;
   }
-  DCHECK(reason != csync::CONFIGURE_REASON_UNKNOWN);
+  DCHECK(reason != syncer::CONFIGURE_REASON_UNKNOWN);
 
   data_type_manager_->Configure(types, reason);
 }
 
-csync::UserShare* ProfileSyncService::GetUserShare() const {
+syncer::UserShare* ProfileSyncService::GetUserShare() const {
   if (backend_.get() && backend_initialized_) {
     return backend_->GetUserShare();
   }
   NOTREACHED();
   return NULL;
 }
 
-csync::sessions::SyncSessionSnapshot
+syncer::sessions::SyncSessionSnapshot
     ProfileSyncService::GetLastSessionSnapshot() const {
   if (backend_.get() && backend_initialized_) {
     return backend_->GetLastSessionSnapshot();
   }
   NOTREACHED();
-  return csync::sessions::SyncSessionSnapshot();
+  return syncer::sessions::SyncSessionSnapshot();
 }
 
 bool ProfileSyncService::HasUnsyncedItems() const {
   if (backend_.get() && backend_initialized_) {
     return backend_->HasUnsyncedItems();
   }
   NOTREACHED();
   return false;
 }
 
 browser_sync::BackendMigrator*
     ProfileSyncService::GetBackendMigratorForTest() {
   return migrator_.get();
 }
 
 void ProfileSyncService::GetModelSafeRoutingInfo(
-    csync::ModelSafeRoutingInfo* out) const {
+    syncer::ModelSafeRoutingInfo* out) const {
   if (backend_.get() && backend_initialized_) {
     backend_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
 }
 
 Value* ProfileSyncService::GetTypeStatusMap() const {
   ListValue* result = new ListValue();
 
   if (!backend_.get() || !backend_initialized_) {
     return result;
   }
 
-  std::vector<csync::SyncError> errors =
+  std::vector<syncer::SyncError> errors =
       failed_datatypes_handler_.GetAllErrors();
-  std::map<ModelType, csync::SyncError> error_map;
-  for (std::vector<csync::SyncError>::iterator it = errors.begin();
+  std::map<ModelType, syncer::SyncError> error_map;
+  for (std::vector<syncer::SyncError>::iterator it = errors.begin();
        it != errors.end(); ++it) {
     error_map[it->type()] = *it;
   }
 
   ModelTypeSet active_types;
   ModelTypeSet passive_types;
   ModelSafeRoutingInfo routing_info;
   backend_->GetModelSafeRoutingInfo(&routing_info);
   for (ModelSafeRoutingInfo::const_iterator it = routing_info.begin();
        it != routing_info.end(); ++it) {
-    if (it->second == csync::GROUP_PASSIVE) {
+    if (it->second == syncer::GROUP_PASSIVE) {
       passive_types.Put(it->first);
     } else {
       active_types.Put(it->first);
     }
   }
 
   SyncBackendHost::Status detailed_status = backend_->GetDetailedStatus();
   ModelTypeSet &throttled_types(detailed_status.throttled_types);
 
   ModelTypeSet registered = GetRegisteredDataTypes();
   for (ModelTypeSet::Iterator it = registered.First(); it.Good(); it.Inc()) {
     ModelType type = it.Get();
     DictionaryValue* type_status = new DictionaryValue();
 
     result->Append(type_status);
     type_status->SetString("name", ModelTypeToString(type));
 
     if (error_map.find(type) != error_map.end()) {
-      const csync::SyncError &error = error_map.find(type)->second;
+      const syncer::SyncError &error = error_map.find(type)->second;
       DCHECK(error.IsSet());
       std::string error_text = "Error: " + error.location().ToString() +
           ", " + error.message();
       type_status->SetString("status", "error");
       type_status->SetString("value", error_text);
     } else if (throttled_types.Has(type) && passive_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Passive, Throttled");
     } else if (passive_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Passive");
     } else if (throttled_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Throttled");
     } else if (active_types.Has(type)) {
       type_status->SetString("status", "ok");
       type_status->SetString("value", "Active: " +
                              ModelSafeGroupToString(routing_info[type]));
     } else {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Disabled by User");
     }
   }
   return result;
 }
 
 void ProfileSyncService::ActivateDataType(
-    syncable::ModelType type, csync::ModelSafeGroup group,
+    syncable::ModelType type, syncer::ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
   DCHECK(backend_initialized_);
   backend_->ActivateDataType(type, group, change_processor);
 }
 
 void ProfileSyncService::DeactivateDataType(syncable::ModelType type) {
   if (!backend_.get())
     return;
   backend_->DeactivateDataType(type);
 }
 
 void ProfileSyncService::ConsumeCachedPassphraseIfPossible() {
   // If no cached passphrase, or sync backend hasn't started up yet, just exit.
   // If the backend isn't running yet, OnBackendInitialized() will call this
   // method again after the backend starts up.
   if (cached_passphrase_.empty() || !sync_initialized())
     return;
 
   // Backend is up and running, so we can consume the cached passphrase.
   std::string passphrase = cached_passphrase_;
   cached_passphrase_.clear();
 
   // If we need a passphrase to decrypt data, try the cached passphrase.
-  if (passphrase_required_reason() == csync::REASON_DECRYPTION) {
+  if (passphrase_required_reason() == syncer::REASON_DECRYPTION) {
     if (SetDecryptionPassphrase(passphrase)) {
       DVLOG(1) << "Cached passphrase successfully decrypted pending keys";
       return;
     }
   }
 
   // If we get here, we don't have pending keys (or at least, the passphrase
   // doesn't decrypt them) - just try to re-encrypt using the encryption
   // passphrase.
   if (!IsUsingSecondaryPassphrase())
     SetEncryptionPassphrase(passphrase, IMPLICIT);
 }
 
 void ProfileSyncService::SetEncryptionPassphrase(const std::string& passphrase,
                                                  PassphraseType type) {
   // This should only be called when the backend has been initialized.
   DCHECK(sync_initialized());
   DCHECK(!(type == IMPLICIT && IsUsingSecondaryPassphrase())) <<
       "Data is already encrypted using an explicit passphrase";
   DCHECK(!(type == EXPLICIT && IsPassphraseRequired())) <<
       "Cannot switch to an explicit passphrase if a passphrase is required";
 
   if (type == EXPLICIT)
     UMA_HISTOGRAM_BOOLEAN("Sync.CustomPassphrase", true);
 
   DVLOG(1) << "Setting " << (type == EXPLICIT ? "explicit" : "implicit")
            << " passphrase for encryption.";
-  if (passphrase_required_reason_ == csync::REASON_ENCRYPTION) {
+  if (passphrase_required_reason_ == syncer::REASON_ENCRYPTION) {
     // REASON_ENCRYPTION implies that the cryptographer does not have pending
     // keys. Hence, as long as we're not trying to do an invalid passphrase
     // change (e.g. explicit -> explicit or explicit -> implicit), we know this
     // will succeed. If for some reason a new encryption key arrives via
     // sync later, the SBH will trigger another OnPassphraseRequired().
-    passphrase_required_reason_ = csync::REASON_PASSPHRASE_NOT_REQUIRED;
+    passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
     NotifyObservers();
   }
   backend_->SetEncryptionPassphrase(passphrase, type == EXPLICIT);
 }
 
 bool ProfileSyncService::SetDecryptionPassphrase(
     const std::string& passphrase) {
   if (IsPassphraseRequired()) {
     DVLOG(1) << "Setting passphrase for decryption.";
     return backend_->SetDecryptionPassphrase(passphrase);
@@ skipping 90 matching lines @@
         return;
       }
 
       // Handle unrecoverable error.
       if (configure_status_ != DataTypeManager::OK &&
           configure_status_ != DataTypeManager::PARTIAL_SUCCESS) {
         // Something catastrophic had happened. We should only have one
         // error representing it.
         DCHECK_EQ(result->failed_data_types.size(),
                   static_cast<unsigned int>(1));
-        csync::SyncError error = result->failed_data_types.front();
+        syncer::SyncError error = result->failed_data_types.front();
         DCHECK(error.IsSet());
         std::string message =
           "Sync configuration failed with status " +
           DataTypeManager::ConfigureStatusToString(configure_status_) +
           " during " + syncable::ModelTypeToString(error.type()) +
           ": " + error.message();
         LOG(ERROR) << "ProfileSyncService error: "
                    << message;
         OnInternalUnrecoverableError(error.location(),
                                      message,
@@ skipping 115 matching lines @@
 }
 
 void ProfileSyncService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool ProfileSyncService::HasObserver(Observer* observer) const {
   return observers_.HasObserver(observer);
 }
 
-base::WeakPtr<csync::JsController> ProfileSyncService::GetJsController() {
+base::WeakPtr<syncer::JsController> ProfileSyncService::GetJsController() {
   return sync_js_controller_.AsWeakPtr();
 }
 
 void ProfileSyncService::SyncEvent(SyncEventCodes code) {
   UMA_HISTOGRAM_ENUMERATION("Sync.EventCodes", code, MAX_SYNC_EVENT_CODE);
 }
 
 // static
 bool ProfileSyncService::IsSyncEnabled() {
   // We have switches::kEnableSync just in case we need to change back to
@@ skipping 85 matching lines @@
   // See http://stackoverflow.com/questions/6224121/is-new-this-myclass-undefined-behaviour-after-directly-calling-the-destru.
   ProfileSyncService* old_this = this;
   this->~ProfileSyncService();
   new(old_this) ProfileSyncService(
       new ProfileSyncComponentsFactoryImpl(profile,
                                            CommandLine::ForCurrentProcess()),
       profile,
       signin,
       behavior);
 }