Converted top-level NewRunnable* to Bind for Sync module

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2011 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 117 matching lines @@
       sync_service_url,
       profile_->GetRequestContext(),
       credentials,
       delete_sync_data_folder,
       sync_prefs_->GetEncryptionBootstrapToken(),
       false));
 }
 
 void SyncBackendHost::InitCore(const Core::DoInitializeOptions& options) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoInitialize,
-                        options));
+      base::Bind(&SyncBackendHost::Core::DoInitialize, core_.get(),options));
 }
 
 void SyncBackendHost::UpdateCredentials(const SyncCredentials& credentials) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(core_.get(),
-                        &SyncBackendHost::Core::DoUpdateCredentials,
-                        credentials));
+      base::Bind(&SyncBackendHost::Core::DoUpdateCredentials, core_.get(),
+                 credentials));
 }
 
 void SyncBackendHost::StartSyncingWithServer() {
   SVLOG(1) << "SyncBackendHost::StartSyncingWithServer called.";
   sync_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoStartSyncing));
+      base::Bind(&SyncBackendHost::Core::DoStartSyncing, core_.get()));
 }
 
 void SyncBackendHost::SetPassphrase(const std::string& passphrase,
                                     bool is_explicit) {
   if (!IsNigoriEnabled()) {
     SLOG(WARNING) << "Silently dropping SetPassphrase request.";
     return;
   }
 
   // This should only be called by the frontend.
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
   // If encryption is enabled and we've got a SetPassphrase
   sync_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoSetPassphrase,
-                        passphrase, is_explicit));
+      base::Bind(&SyncBackendHost::Core::DoSetPassphrase, core_.get(),
+                 passphrase, is_explicit));
 }
 
 void SyncBackendHost::StopSyncManagerForShutdown(
     const base::Closure& closure) {
   DCHECK_GT(initialization_state_, NOT_ATTEMPTED);
   if (initialization_state_ == CREATING_SYNC_MANAGER) {
     // We post here to implicitly wait for the SyncManager to be created,
     // if needed.  We have to wait, since we need to shutdown immediately,
     // and we need to tell the SyncManager so it can abort any activity
     // (net I/O, data application).
@@ skipping 36 matching lines @@
     // so the registrar won't need stopping either.
     DCHECK_EQ(NOT_ATTEMPTED, initialization_state_);
     DCHECK(!registrar_.get());
   }
 }
 
 void SyncBackendHost::Shutdown(bool sync_disabled) {
   // TODO(tim): DCHECK(registrar_->StoppedOnUIThread()) would be nice.
   if (sync_thread_.IsRunning()) {
     sync_thread_.message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(core_.get(),
-                          &SyncBackendHost::Core::DoShutdown,
-                          sync_disabled));
+        base::Bind(&SyncBackendHost::Core::DoShutdown, core_.get(),
+                   sync_disabled));
   }
 
   // Stop will return once the thread exits, which will be after DoShutdown
   // runs. DoShutdown needs to run from sync_thread_ because the sync backend
   // requires any thread that opened sqlite handles to relinquish them
   // personally. We need to join threads, because otherwise the main Chrome
   // thread (ui loop) can exit before DoShutdown finishes, at which point
   // virtually anything the sync backend does (or the post-back to
   // frontend_loop_ by our Core) will epically fail because the CRT won't be
   // initialized.
@@ skipping 37 matching lines @@
       registrar_->ConfigureDataTypes(types_to_add_with_nigori,
                                      types_to_remove_with_nigori);
   pending_config_mode_state_->reason = reason;
 
   // 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()) {
     sync_thread_.message_loop()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(
-            core_.get(),
-            &SyncBackendHost::Core::DoRequestCleanupDisabledTypes));
+        base::Bind(&SyncBackendHost::Core::DoRequestCleanupDisabledTypes,
+                   core_.get()));
   }
 
-  StartConfiguration(base::Bind(
-      &SyncBackendHost::Core::FinishConfigureDataTypes, core_.get()));
+  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, NewRunnableMethod(
-      core_.get(), &SyncBackendHost::Core::DoStartConfiguration, callback));
+  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,
-     NewRunnableMethod(core_.get(),
-                       &SyncBackendHost::Core::DoEnableEncryptEverything));
+     base::Bind(&SyncBackendHost::Core::DoEnableEncryptEverything,
+                core_.get()));
 }
 
 void SyncBackendHost::ActivateDataType(
     syncable::ModelType type, ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
 
 void SyncBackendHost::DeactivateDataType(syncable::ModelType type) {
   registrar_->DeactivateDataType(type);
 }
 
 bool SyncBackendHost::RequestClearServerData() {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
-     NewRunnableMethod(core_.get(),
-     &SyncBackendHost::Core::DoRequestClearServerData));
+      base::Bind(&SyncBackendHost::Core::DoRequestClearServerData,
+                 core_.get()));
   return true;
 }
 
-
 sync_api::UserShare* SyncBackendHost::GetUserShare() const {
   DCHECK(initialized());
   return core_->sync_manager()->GetUserShare();
 }
 
 SyncBackendHost::Status SyncBackendHost::GetDetailedStatus() {
   DCHECK(initialized());
   return core_->sync_manager()->GetDetailedStatus();
 }
 
@@ skipping 64 matching lines @@
 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_);
-  host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
+  host_->frontend_loop_->PostTask(FROM_HERE, base::Bind(
       &Core::HandleSyncCycleCompletedOnFrontendLoop,
+      this,
       new SyncSessionSnapshot(*snapshot)));
 }
 
 
 void SyncBackendHost::Core::OnInitializationComplete(
     const WeakHandle<JsBackend>& js_backend,
     bool success) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   host_->frontend_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this,
-                        &Core::HandleInitializationCompletedOnFrontendLoop,
-                        js_backend, success));
+      base::Bind(&Core::HandleInitializationCompletedOnFrontendLoop, this,
+                 js_backend, success));
 
   // Initialization is complete, so we can schedule recurring SaveChanges.
-  sync_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &Core::StartSavingChanges));
+  sync_loop_->PostTask(FROM_HERE, base::Bind(&Core::StartSavingChanges, this));
 }
 
 void SyncBackendHost::Core::OnAuthError(const AuthError& auth_error) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // Post to our core loop so we can modify state. Could be on another thread.
   host_->frontend_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &Core::HandleAuthErrorEventOnFrontendLoop,
-      auth_error));
+      base::Bind(&Core::HandleAuthErrorEventOnFrontendLoop, this, auth_error));
 }
 
 void SyncBackendHost::Core::OnPassphraseRequired(
     sync_api::PassphraseRequiredReason reason) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &Core::NotifyPassphraseRequired, reason));
+      base::Bind(&Core::NotifyPassphraseRequired, this, reason));
 }
 
 void SyncBackendHost::Core::OnPassphraseAccepted(
     const std::string& bootstrap_token) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &Core::NotifyPassphraseAccepted,
-          bootstrap_token));
+      base::Bind(&Core::NotifyPassphraseAccepted, this, bootstrap_token));
 }
 
 void SyncBackendHost::Core::OnStopSyncingPermanently() {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &Core::HandleStopSyncingPermanentlyOnFrontendLoop));
+  host_->frontend_loop_->PostTask(FROM_HERE, base::Bind(
+      &Core::HandleStopSyncingPermanentlyOnFrontendLoop, this));
 }
 
 void SyncBackendHost::Core::OnUpdatedToken(const std::string& token) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &Core::NotifyUpdatedToken, token));
+  host_->frontend_loop_->PostTask(FROM_HERE, base::Bind(
+      &Core::NotifyUpdatedToken, this, token));
 }
 
 void SyncBackendHost::Core::OnClearServerDataFailed() {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &Core::HandleClearServerDataFailedOnFrontendLoop));
+  host_->frontend_loop_->PostTask(FROM_HERE, base::Bind(
+      &Core::HandleClearServerDataFailedOnFrontendLoop, this));
 }
 
 void SyncBackendHost::Core::OnClearServerDataSucceeded() {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &Core::HandleClearServerDataSucceededOnFrontendLoop));
+  host_->frontend_loop_->PostTask(FROM_HERE, base::Bind(
+      &Core::HandleClearServerDataSucceededOnFrontendLoop, this));
 }
 
 void SyncBackendHost::Core::OnEncryptedTypesChanged(
     const syncable::ModelTypeSet& encrypted_types,
     bool encrypt_everything) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // NOTE: We're in a transaction.
   host_->frontend_loop_->PostTask(
@@ skipping 12 matching lines @@
       base::Bind(&Core::NotifyEncryptionComplete, this));
 }
 
 void SyncBackendHost::Core::OnActionableError(
     const browser_sync::SyncProtocolError& sync_error) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &Core::HandleActionableErrorEventOnFrontendLoop,
-                        sync_error));
+      base::Bind(&Core::HandleActionableErrorEventOnFrontendLoop, this,
+                 sync_error));
 }
 
 SyncBackendHost::Core::DoInitializeOptions::DoInitializeOptions(
     MessageLoop* sync_loop,
     SyncBackendRegistrar* registrar,
     const WeakHandle<JsEventHandler>& event_handler,
     const GURL& service_url,
     const scoped_refptr<net::URLRequestContextGetter>&
         request_context_getter,
     const sync_api::SyncCredentials& credentials,
@@ skipping 173 matching lines @@
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
     if (!file_util::Delete(host_->sync_data_folder_path(), true))
       SLOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 void SyncBackendHost::Core::FinishConfigureDataTypes() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &SyncBackendHost::Core::FinishConfigureDataTypesOnFrontendLoop));
+  host_->frontend_loop_->PostTask(FROM_HERE, base::Bind(
+      &SyncBackendHost::Core::FinishConfigureDataTypesOnFrontendLoop, this));
 }
 
 void SyncBackendHost::Core::HandleInitializationCompletedOnFrontendLoop(
     const WeakHandle<JsBackend>& js_backend,
     bool success) {
   if (!host_)
     return;
   host_->HandleInitializationCompletedOnFrontendLoop(js_backend, success);
 }
 
@@ skipping 210 matching lines @@
       initialization_state_ = INITIALIZED;
       // Now that we've downloaded the nigori node, 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, true);
       // Now that we're fully initialized, kick off a server
       // reachability check.
       sync_thread_.message_loop()->PostTask(
           FROM_HERE,
-          NewRunnableMethod(
-              core_.get(),
-              &SyncBackendHost::Core::DoCheckServerReachable));
+          base::Bind(&SyncBackendHost::Core::DoCheckServerReachable,
+                     core_.get()));
       break;
     default:
       NOTREACHED();
   }
 }
 
 void SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop() {
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   // Nudge the syncer. This is necessary for both datatype addition/deletion.
   //
@@ skipping 32 matching lines @@
 
     // Always configure nigori if it's enabled.
     syncable::ModelTypeSet types_to_config =
         pending_download_state_->added_types;
     if (IsNigoriEnabled()) {
       types_to_config.insert(syncable::NIGORI);
     }
     SVLOG(1) << "Types " << ModelTypeSetToString(types_to_config)
             << " added; calling DoRequestConfig";
     sync_thread_.message_loop()->PostTask(FROM_HERE,
-         NewRunnableMethod(core_.get(),
-                           &SyncBackendHost::Core::DoRequestConfig,
-                           syncable::ModelTypeBitSetFromSet(types_to_config),
-                           pending_download_state_->reason));
+         base::Bind(&SyncBackendHost::Core::DoRequestConfig,
+                    core_.get(),
+                    syncable::ModelTypeBitSetFromSet(types_to_config),
+                    pending_download_state_->reason));
   }
 
   pending_config_mode_state_.reset();
 
   // Notify the SyncManager about the new types.
   sync_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(core_.get(),
-                        &SyncBackendHost::Core::DoUpdateEnabledTypes));
+      base::Bind(&SyncBackendHost::Core::DoUpdateEnabledTypes, core_.get()));
 }
 
 sync_api::HttpPostProviderFactory* SyncBackendHost::MakeHttpBridgeFactory(
     const scoped_refptr<net::URLRequestContextGetter>& getter) {
   return new HttpBridgeFactory(getter);
 }
 
 void SyncBackendHost::PersistEncryptionBootstrapToken(
     const std::string& token) {
   CHECK(sync_prefs_.get());
@@ skipping 27 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshEncryption,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync