chrome: Use base::MessageLoop. (Part 3)

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 251 matching lines @@
   const std::string name_;
 
   // Path of the folder that stores the sync data files.
   const base::FilePath sync_data_folder_path_;
 
   // Our parent SyncBackendHost.
   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_;
+  base::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_;
@@ skipping 60 matching lines @@
 
 }  // namespace
 
 SyncBackendHost::SyncBackendHost(
     const std::string& name,
     Profile* profile,
     const base::WeakPtr<SyncPrefs>& sync_prefs,
     const base::WeakPtr<InvalidatorStorage>& invalidator_storage)
     : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       sync_thread_("Chrome_SyncThread"),
-      frontend_loop_(MessageLoop::current()),
+      frontend_loop_(base::MessageLoop::current()),
       profile_(profile),
       name_(name),
-      core_(new Core(name, profile_->GetPath().Append(kSyncDataFolderName),
+      core_(new Core(name,
+                     profile_->GetPath().Append(kSyncDataFolderName),
                      weak_ptr_factory_.GetWeakPtr())),
       initialization_state_(NOT_ATTEMPTED),
       sync_prefs_(sync_prefs),
       invalidator_factory_(
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
           invalidator_storage),
       frontend_(NULL),
-      cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE) {
-}
+      cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE) {}
 
 SyncBackendHost::SyncBackendHost(Profile* profile)
     : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       sync_thread_("Chrome_SyncThread"),
-      frontend_loop_(MessageLoop::current()),
+      frontend_loop_(base::MessageLoop::current()),
       profile_(profile),
       name_("Unknown"),
       initialization_state_(NOT_ATTEMPTED),
       invalidator_factory_(
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
           base::WeakPtr<syncer::InvalidationStateTracker>()),
       frontend_(NULL),
-      cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE) {
-}
+      cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE) {}
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(!android_invalidator_bridge_.get());
   DCHECK(!registrar_.get());
 }
 
 namespace {
 
 scoped_ptr<syncer::HttpPostProviderFactory> MakeHttpBridgeFactory(
@@ skipping 70 matching lines @@
 
 void SyncBackendHost::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(sync_thread_.IsRunning());
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoUpdateCredentials, core_.get(),
                  credentials));
 }
 
 void SyncBackendHost::UpdateRegisteredInvalidationIds(
     const syncer::ObjectIdSet& ids) {
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   DCHECK(sync_thread_.IsRunning());
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoUpdateRegisteredInvalidationIds,
                  core_.get(), ids));
 }
 
 void SyncBackendHost::AcknowledgeInvalidation(
     const invalidation::ObjectId& id, const syncer::AckHandle& ack_handle) {
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   DCHECK(sync_thread_.IsRunning());
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoAcknowledgeInvalidation,
                  core_.get(), id, ack_handle));
 }
 
 void SyncBackendHost::StartSyncingWithServer() {
   SDVLOG(1) << "SyncBackendHost::StartSyncingWithServer called.";
 
   syncer::ModelSafeRoutingInfo routing_info;
@@ skipping 10 matching lines @@
   if (!IsNigoriEnabled()) {
     NOTREACHED() << "SetEncryptionPassphrase must never be called when nigori"
                     " is disabled.";
     return;
   }
 
   // We should never be called with an empty passphrase.
   DCHECK(!passphrase.empty());
 
   // This should only be called by the frontend.
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   // SetEncryptionPassphrase should never be called if we are currently
   // encrypted with an explicit passphrase.
   DCHECK(cached_passphrase_type_ == syncer::KEYSTORE_PASSPHRASE ||
          cached_passphrase_type_ == syncer::IMPLICIT_PASSPHRASE);
 
   // Post an encryption task on the syncer thread.
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoSetEncryptionPassphrase, core_.get(),
                  passphrase, is_explicit));
 }
 
 bool SyncBackendHost::SetDecryptionPassphrase(const std::string& passphrase) {
   if (!IsNigoriEnabled()) {
     NOTREACHED() << "SetDecryptionPassphrase must never be called when nigori"
                     " is disabled.";
     return false;
   }
 
   // We should never be called with an empty passphrase.
   DCHECK(!passphrase.empty());
 
   // This should only be called by the frontend.
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   // This should only be called when we have cached pending keys.
   DCHECK(cached_pending_keys_.has_blob());
 
   // Check the passphrase that was provided against our local cache of the
   // cryptographer's pending keys. If this was unsuccessful, the UI layer can
   // immediately call OnPassphraseRequired without showing the user a spinner.
   if (!CheckPassphraseAgainstCachedPendingKeys(passphrase))
     return false;
 
@@ skipping 28 matching lines @@
         base::Bind(
             &SyncBackendHost::Core::DoStopSyncManagerForShutdown,
             core_.get(),
             closure));
   } else {
     core_->DoStopSyncManagerForShutdown(closure);
   }
 }
 
 void SyncBackendHost::StopSyncingForShutdown() {
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   // Immediately stop sending messages to the frontend.
   frontend_ = NULL;
 
   // Stop listening for and forwarding locally-triggered sync refresh requests.
   notification_registrar_.RemoveAll();
 
   // Thread shutdown should occur in the following order:
   // - Sync Thread
   // - UI Thread (stops some time after we return from this call).
@@ skipping 232 matching lines @@
                   routing_info,
                   ready_task,
                   retry_callback));
 }
 
 void SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop(
     syncer::ModelTypeSet failed_configuration_types,
     const base::Callback<void(syncer::ModelTypeSet)>& ready_task) {
   if (!frontend_)
     return;
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   if (!ready_task.is_null())
     ready_task.Run(failed_configuration_types);
 }
 
 void SyncBackendHost::HandleSyncManagerInitializationOnFrontendLoop(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     syncer::ModelTypeSet restored_types) {
   DCHECK_EQ(initialization_state_, CREATING_SYNC_MANAGER);
@@ skipping 31 matching lines @@
       state_details(details);
   const syncer::ModelTypeInvalidationMap& invalidation_map =
       *(state_details.ptr());
   const syncer::ModelTypeSet types =
       ModelTypeInvalidationMapToSet(invalidation_map);
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshTypes, core_.get(), types));
 }
 
 SyncBackendHost::DoInitializeOptions::DoInitializeOptions(
-    MessageLoop* sync_loop,
+    base::MessageLoop* sync_loop,
     SyncBackendRegistrar* registrar,
     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 syncer::SyncCredentials& credentials,
     AndroidInvalidatorBridge* android_invalidator_bridge,
     syncer::InvalidatorFactory* invalidator_factory,
@@ skipping 16 matching lines @@
       credentials(credentials),
       android_invalidator_bridge(android_invalidator_bridge),
       invalidator_factory(invalidator_factory),
       sync_manager_factory(sync_manager_factory),
       delete_sync_data_folder(delete_sync_data_folder),
       restored_key_for_bootstrapping(restored_key_for_bootstrapping),
       restored_keystore_key_for_bootstrapping(
           restored_keystore_key_for_bootstrapping),
       internal_components_factory(internal_components_factory),
       unrecoverable_error_handler(unrecoverable_error_handler),
-      report_unrecoverable_error_function(
-          report_unrecoverable_error_function) {
+      report_unrecoverable_error_function(report_unrecoverable_error_function) {
 }
 
 SyncBackendHost::DoInitializeOptions::~DoInitializeOptions() {}
 
 SyncBackendHost::Core::Core(const std::string& name,
                             const base::FilePath& sync_data_folder_path,
                             const base::WeakPtr<SyncBackendHost>& backend)
     : name_(name),
       sync_data_folder_path_(sync_data_folder_path),
       host_(backend),
       sync_loop_(NULL),
       registrar_(NULL),
       registered_as_invalidation_handler_(false) {
   DCHECK(backend.get());
 }
 
 SyncBackendHost::Core::~Core() {
   DCHECK(!sync_manager_.get());
   DCHECK(!sync_loop_);
 }
 
 void SyncBackendHost::Core::OnSyncCycleCompleted(
     const SyncSessionSnapshot& snapshot) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
 
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleSyncCycleCompletedOnFrontendLoop,
       snapshot);
 }
 
 void SyncBackendHost::Core::DoDownloadControlTypes() {
   syncer::ModelTypeSet new_control_types = registrar_->ConfigureDataTypes(
       syncer::ControlTypes(), syncer::ModelTypeSet());
   syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   SDVLOG(1) << "Control Types "
             << syncer::ModelTypeSetToString(new_control_types)
             << " added; calling DoConfigureSyncer";
 
   sync_manager_->ConfigureSyncer(
       syncer::CONFIGURE_REASON_NEW_CLIENT,
       new_control_types,
       syncer::ModelTypeSet(),
       routing_info,
       base::Bind(&SyncBackendHost::Core::DoInitialProcessControlTypes,
                  this),
       base::Bind(&SyncBackendHost::Core::OnControlTypesDownloadRetry,
                  this));
 }
 
 void SyncBackendHost::Core::DoRefreshTypes(syncer::ModelTypeSet types) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   sync_manager_->RefreshTypes(types);
 }
 
 void SyncBackendHost::Core::OnControlTypesDownloadRetry() {
   host_.Call(FROM_HERE,
              &SyncBackendHost::HandleControlTypesDownloadRetry);
 }
 
 void SyncBackendHost::Core::OnInitializationComplete(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     bool success,
     const syncer::ModelTypeSet restored_types) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
 
   if (!success) {
     DoDestroySyncManager();
     host_.Call(FROM_HERE,
                &SyncBackendHost::HandleInitializationCompletedOnFrontendLoop,
                false);
     return;
   }
 
   // Register for encryption related changes now. We have to do this before
@@ skipping 11 matching lines @@
              &SyncBackendHost::HandleSyncManagerInitializationOnFrontendLoop,
              js_backend,
              debug_info_listener,
              restored_types);
 }
 
 void SyncBackendHost::Core::OnConnectionStatusChange(
     syncer::ConnectionStatus status) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHost::HandleConnectionStatusChangeOnFrontendLoop, status);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  host_.Call(FROM_HERE,
+             &SyncBackendHost::HandleConnectionStatusChangeOnFrontendLoop,
+             status);
 }
 
 void SyncBackendHost::Core::OnPassphraseRequired(
     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);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  host_.Call(FROM_HERE,
+             &SyncBackendHost::NotifyPassphraseRequired,
+             reason,
+             pending_keys);
 }
 
 void SyncBackendHost::Core::OnPassphraseAccepted() {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHost::NotifyPassphraseAccepted);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  host_.Call(FROM_HERE, &SyncBackendHost::NotifyPassphraseAccepted);
 }
 
 void SyncBackendHost::Core::OnBootstrapTokenUpdated(
     const std::string& bootstrap_token,
     syncer::BootstrapTokenType type) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
              &SyncBackendHost::PersistEncryptionBootstrapToken,
              bootstrap_token,
              type);
 }
 
 void SyncBackendHost::Core::OnStopSyncingPermanently() {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHost::HandleStopSyncingPermanentlyOnFrontendLoop);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  host_.Call(FROM_HERE,
+             &SyncBackendHost::HandleStopSyncingPermanentlyOnFrontendLoop);
 }
 
 void SyncBackendHost::Core::OnUpdatedToken(const std::string& token) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHost::NotifyUpdatedToken, token);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  host_.Call(FROM_HERE, &SyncBackendHost::NotifyUpdatedToken, token);
 }
 
 void SyncBackendHost::Core::OnEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   // NOTE: We're in a transaction.
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyEncryptedTypesChanged,
       encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHost::Core::OnEncryptionComplete() {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   // NOTE: We're in a transaction.
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyEncryptionComplete);
 }
 
 void SyncBackendHost::Core::OnCryptographerStateChanged(
     syncer::Cryptographer* cryptographer) {
   // Do nothing.
 }
 
 void SyncBackendHost::Core::OnPassphraseTypeChanged(
     syncer::PassphraseType type, base::Time passphrase_time) {
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandlePassphraseTypeChangedOnFrontendLoop,
       type, passphrase_time);
 }
 
 void SyncBackendHost::Core::OnActionableError(
     const syncer::SyncProtocolError& sync_error) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHost::HandleActionableErrorEventOnFrontendLoop,
-      sync_error);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  host_.Call(FROM_HERE,
+             &SyncBackendHost::HandleActionableErrorEventOnFrontendLoop,
+             sync_error);
 }
 
 void SyncBackendHost::Core::OnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
              &SyncBackendHost::HandleInvalidatorStateChangeOnFrontendLoop,
              state);
 }
 
 void SyncBackendHost::Core::OnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map) {
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
              &SyncBackendHost::HandleIncomingInvalidationOnFrontendLoop,
              invalidation_map);
 }
 
 void SyncBackendHost::Core::DoInitialize(const DoInitializeOptions& options) {
   DCHECK(!sync_loop_);
   sync_loop_ = options.sync_loop;
   DCHECK(sync_loop_);
 
@@ skipping 59 matching lines @@
     // would be encountered.
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kSyncThrowUnrecoverableError)) {
       sync_manager_->ThrowUnrecoverableError();
     }
   }
 }
 
 void SyncBackendHost::Core::DoUpdateCredentials(
     const SyncCredentials& credentials) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   // UpdateCredentials can be called during backend initialization, possibly
   // when backend initialization has failed but hasn't notified the UI thread
   // yet. In that case, the sync manager may have been destroyed on the sync
   // thread before this task was executed, so we do nothing.
   if (sync_manager_.get()) {
     sync_manager_->UpdateCredentials(credentials);
   }
 }
 
 void SyncBackendHost::Core::DoUpdateRegisteredInvalidationIds(
     const syncer::ObjectIdSet& ids) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   // |sync_manager_| may end up being NULL here in tests (in
   // synchronous initialization mode) since this is called during
   // shutdown.
   //
   // TODO(akalin): Fix this behavior (see http://crbug.com/140354).
   if (sync_manager_.get()) {
     sync_manager_->UpdateRegisteredInvalidationIds(this, ids);
   }
 }
 
 void SyncBackendHost::Core::DoAcknowledgeInvalidation(
     const invalidation::ObjectId& id, const syncer::AckHandle& ack_handle) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   // |sync_manager_| may end up being NULL here in tests (in
   // synchronous initialization mode).
   //
   // TODO(akalin): Fix this behavior (see http://crbug.com/140354).
   if (sync_manager_.get()) {
     sync_manager_->AcknowledgeInvalidation(id, ack_handle);
   }
 }
 
 void SyncBackendHost::Core::DoStartSyncing(
     const syncer::ModelSafeRoutingInfo& routing_info) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   sync_manager_->StartSyncingNormally(routing_info);
 }
 
 void SyncBackendHost::Core::DoSetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  sync_manager_->GetEncryptionHandler()->SetEncryptionPassphrase(
-      passphrase, is_explicit);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  sync_manager_->GetEncryptionHandler()
+      ->SetEncryptionPassphrase(passphrase, is_explicit);
 }
 
 void SyncBackendHost::Core::DoInitialProcessControlTypes() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
 
   DVLOG(1) << "Initilalizing Control Types";
 
   // Initialize encryption.
   sync_manager_->GetEncryptionHandler()->Init();
 
   // Note: experiments are currently handled via SBH::AddExperimentalTypes,
   // which is called at the end of every sync cycle.
   // TODO(zea): eventually add an experiment handler and initialize it here.
 
@@ skipping 32 matching lines @@
                                sync_manager_->GetUserShare());
 
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleInitializationCompletedOnFrontendLoop,
       true);
 }
 
 void SyncBackendHost::Core::DoSetDecryptionPassphrase(
     const std::string& passphrase) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  sync_manager_->GetEncryptionHandler()->SetDecryptionPassphrase(
-      passphrase);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
+  sync_manager_->GetEncryptionHandler()->SetDecryptionPassphrase(passphrase);
 }
 
 void SyncBackendHost::Core::DoEnableEncryptEverything() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   sync_manager_->GetEncryptionHandler()->EnableEncryptEverything();
 }
 
 void SyncBackendHost::Core::DoStopSyncManagerForShutdown(
     const base::Closure& closure) {
   if (sync_manager_.get()) {
     sync_manager_->StopSyncingForShutdown(closure);
   } else {
     sync_loop_->PostTask(FROM_HERE, closure);
   }
 }
 
 void SyncBackendHost::Core::DoShutdown(bool sync_disabled) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   // It's safe to do this even if the type was never activated.
   registrar_->DeactivateDataType(syncer::DEVICE_INFO);
   synced_device_tracker_.reset();
 
   DoDestroySyncManager();
 
   registrar_ = NULL;
 
   if (sync_disabled)
     DeleteSyncDataFolder();
 
   sync_loop_ = NULL;
 
   host_.Reset();
 }
 
 void SyncBackendHost::Core::DoDestroySyncManager() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   if (sync_manager_.get()) {
     save_changes_timer_.reset();
     if (registered_as_invalidation_handler_) {
       sync_manager_->UnregisterInvalidationHandler(this);
       registered_as_invalidation_handler_ = false;
     }
     sync_manager_->RemoveObserver(this);
     sync_manager_->ShutdownOnSyncThread();
     sync_manager_.reset();
   }
 }
 
 void SyncBackendHost::Core::DoConfigureSyncer(
     syncer::ConfigureReason reason,
     syncer::ModelTypeSet types_to_config,
     syncer::ModelTypeSet failed_types,
     const syncer::ModelSafeRoutingInfo routing_info,
     const base::Callback<void(syncer::ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   sync_manager_->ConfigureSyncer(
       reason,
       types_to_config,
       failed_types,
       routing_info,
       base::Bind(&SyncBackendHost::Core::DoFinishConfigureDataTypes,
                  this,
                  types_to_config,
                  ready_task),
-      base::Bind(&SyncBackendHost::Core::DoRetryConfiguration,
-                 this,
-                 retry_callback));
+      base::Bind(
+          &SyncBackendHost::Core::DoRetryConfiguration, this, retry_callback));
 }
 
 void SyncBackendHost::Core::DoFinishConfigureDataTypes(
     syncer::ModelTypeSet types_to_config,
     const base::Callback<void(syncer::ModelTypeSet)>& ready_task) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
 
   // Update the enabled types for the bridge and sync manager.
   syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   syncer::ModelTypeSet enabled_types = GetRoutingInfoTypes(routing_info);
   enabled_types.RemoveAll(syncer::ProxyTypes());
   sync_manager_->UpdateEnabledTypes(enabled_types);
 
   const syncer::ModelTypeSet failed_configuration_types =
       Difference(types_to_config, sync_manager_->InitialSyncEndedTypes());
   host_.Call(FROM_HERE,
              &SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop,
              failed_configuration_types,
              ready_task);
 }
 
 void SyncBackendHost::Core::DoRetryConfiguration(
     const base::Closure& retry_callback) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
              &SyncBackendHost::RetryConfigurationOnFrontendLoop,
              retry_callback);
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   if (file_util::DirectoryExists(sync_data_folder_path_)) {
     if (!file_util::Delete(sync_data_folder_path_, true))
       SLOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 void SyncBackendHost::Core::StartSavingChanges() {
   // We may already be shut down.
   if (!sync_loop_)
     return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   DCHECK(!save_changes_timer_.get());
   save_changes_timer_.reset(new base::RepeatingTimer<Core>());
   save_changes_timer_->Start(FROM_HERE,
       base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
       this, &Core::SaveChanges);
 }
 
 void SyncBackendHost::Core::SaveChanges() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   sync_manager_->SaveChanges();
 }
 
 void SyncBackendHost::AddExperimentalTypes() {
   CHECK(initialized());
   syncer::Experiments experiments;
   if (core_->sync_manager()->ReceivedExperiment(&experiments))
     frontend_->OnExperimentsChanged(experiments);
 }
 
 void SyncBackendHost::HandleControlTypesDownloadRetry() {
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   if (!frontend_)
     return;
 
   frontend_->OnSyncConfigureRetry();
 }
 
 void SyncBackendHost::HandleInitializationCompletedOnFrontendLoop(
     bool success) {
   DCHECK_NE(initialization_state_, NOT_ATTEMPTED);
   if (!frontend_)
     return;
 
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   if (!success) {
     js_backend_.Reset();
     initialization_state_ = NOT_INITIALIZED;
     frontend_->OnBackendInitialized(
         syncer::WeakHandle<syncer::JsBackend>(),
         syncer::WeakHandle<syncer::DataTypeDebugInfoListener>(),
         false);
     return;
   }
 
   initialization_state_ = INITIALIZED;
 
   // Now that we've downloaded the control types, we can see if there are any
   // experimental types to enable. This should be done before we inform
   // the frontend to ensure they're visible in the customize screen.
   AddExperimentalTypes();
   frontend_->OnBackendInitialized(js_backend_,
                                   debug_info_listener_,
                                   true);
   js_backend_.Reset();
 }
 
 void SyncBackendHost::HandleSyncCycleCompletedOnFrontendLoop(
     const SyncSessionSnapshot& snapshot) {
   if (!frontend_)
     return;
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   last_snapshot_ = snapshot;
 
   SDVLOG(1) << "Got snapshot " << snapshot.ToString();
 
   const syncer::ModelTypeSet to_migrate =
       snapshot.model_neutral_state().types_needing_local_migration;
   if (!to_migrate.Empty())
     frontend_->OnMigrationNeededForTypes(to_migrate);
 
@@ skipping 20 matching lines @@
   if (token_type == syncer::PASSPHRASE_BOOTSTRAP_TOKEN)
     sync_prefs_->SetEncryptionBootstrapToken(token);
   else
     sync_prefs_->SetKeystoreEncryptionBootstrapToken(token);
 }
 
 void SyncBackendHost::HandleActionableErrorEventOnFrontendLoop(
     const syncer::SyncProtocolError& sync_error) {
   if (!frontend_)
     return;
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   frontend_->OnActionableError(sync_error);
 }
 
 void SyncBackendHost::HandleInvalidatorStateChangeOnFrontendLoop(
     syncer::InvalidatorState state) {
   if (!frontend_)
     return;
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   frontend_->OnInvalidatorStateChange(state);
 }
 
 void SyncBackendHost::HandleIncomingInvalidationOnFrontendLoop(
     const syncer::ObjectIdInvalidationMap& invalidation_map) {
   if (!frontend_)
     return;
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   frontend_->OnIncomingInvalidation(invalidation_map);
 }
 
 bool SyncBackendHost::CheckPassphraseAgainstCachedPendingKeys(
     const std::string& passphrase) const {
   DCHECK(cached_pending_keys_.has_blob());
   DCHECK(!passphrase.empty());
   syncer::Nigori nigori;
   nigori.InitByDerivation("localhost", "dummy", passphrase);
   std::string plaintext;
   bool result = nigori.Decrypt(cached_pending_keys_.blob(), &plaintext);
   DVLOG_IF(1, result) << "Passphrase failed to decrypt pending keys.";
   return result;
 }
 
 void SyncBackendHost::NotifyPassphraseRequired(
     syncer::PassphraseRequiredReason reason,
     sync_pb::EncryptedData pending_keys) {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   // Update our cache of the cryptographer's pending keys.
   cached_pending_keys_ = pending_keys;
 
   frontend_->OnPassphraseRequired(reason, pending_keys);
 }
 
 void SyncBackendHost::NotifyPassphraseAccepted() {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   // Clear our cache of the cryptographer's pending keys.
   cached_pending_keys_.clear_blob();
   frontend_->OnPassphraseAccepted();
 }
 
 void SyncBackendHost::NotifyUpdatedToken(const std::string& token) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TokenAvailableDetails details(GaiaConstants::kSyncService, token);
 
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   CHECK(token_service);
   token_service->AddAuthTokenManually(details.service(), details.token());
 }
 
 void SyncBackendHost::NotifyEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
-  frontend_->OnEncryptedTypesChanged(
-      encrypted_types, encrypt_everything);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
+  frontend_->OnEncryptedTypesChanged(encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHost::NotifyEncryptionComplete() {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   frontend_->OnEncryptionComplete();
 }
 
 void SyncBackendHost::HandlePassphraseTypeChangedOnFrontendLoop(
     syncer::PassphraseType type,
     base::Time explicit_passphrase_time) {
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   DVLOG(1) << "Passphrase type changed to "
            << syncer::PassphraseTypeToString(type);
   cached_passphrase_type_ = type;
   cached_explicit_passphrase_time_ = explicit_passphrase_time;
 }
 
 void SyncBackendHost::HandleStopSyncingPermanentlyOnFrontendLoop() {
   if (!frontend_)
     return;
   frontend_->OnStopSyncingPermanently();
 }
 
 void SyncBackendHost::HandleConnectionStatusChangeOnFrontendLoop(
     syncer::ConnectionStatus status) {
   if (!frontend_)
     return;
 
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   DVLOG(1) << "Connection status changed: "
            << syncer::ConnectionStatusToString(status);
   frontend_->OnConnectionStatusChange(status);
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync