Converted top-level NewRunnable* to Bind for Sync module

chrome/browser/sync/notifier/non_blocking_invalidation_notifier.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 "chrome/browser/sync/notifier/non_blocking_invalidation_notifier.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/observer_list_threadsafe.h"
@@ skipping 141 matching lines @@
     const browser_sync::WeakHandle<InvalidationVersionTracker>&
         invalidation_version_tracker,
     const std::string& client_info)
         : core_(new Core),
           parent_message_loop_proxy_(
               base::MessageLoopProxy::current()),
           io_message_loop_proxy_(notifier_options.request_context_getter->
               GetIOMessageLoopProxy()) {
   if (!io_message_loop_proxy_->PostTask(
           FROM_HERE,
-          NewRunnableMethod(
+          base::Bind(
+              &NonBlockingInvalidationNotifier::Core::Initialize,
               core_.get(),
-              &NonBlockingInvalidationNotifier::Core::Initialize,
               notifier_options,
               initial_max_invalidation_versions,
               invalidation_version_tracker,
               client_info))) {
     NOTREACHED();
   }
 }
 
 NonBlockingInvalidationNotifier::~NonBlockingInvalidationNotifier() {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   if (!io_message_loop_proxy_->PostTask(
           FROM_HERE,
-          NewRunnableMethod(
-              core_.get(),
-              &NonBlockingInvalidationNotifier::Core::Teardown))) {
+          base::Bind(&NonBlockingInvalidationNotifier::Core::Teardown,
+                     core_.get()))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidationNotifier::AddObserver(
     SyncNotifierObserver* observer) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   core_->AddObserver(observer);
 }
 
 void NonBlockingInvalidationNotifier::RemoveObserver(
     SyncNotifierObserver* observer) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   core_->RemoveObserver(observer);
 }
 
 void NonBlockingInvalidationNotifier::SetUniqueId(
     const std::string& unique_id) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   if (!io_message_loop_proxy_->PostTask(
           FROM_HERE,
-          NewRunnableMethod(
-              core_.get(),
-              &NonBlockingInvalidationNotifier::Core::SetUniqueId,
-              unique_id))) {
+          base::Bind(&NonBlockingInvalidationNotifier::Core::SetUniqueId,
+                     core_.get(), unique_id))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidationNotifier::SetState(const std::string& state) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   if (!io_message_loop_proxy_->PostTask(
           FROM_HERE,
-          NewRunnableMethod(
-              core_.get(),
-              &NonBlockingInvalidationNotifier::Core::SetState,
-              state))) {
+          base::Bind(&NonBlockingInvalidationNotifier::Core::SetState,
+                     core_.get(), state))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidationNotifier::UpdateCredentials(
     const std::string& email, const std::string& token) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   if (!io_message_loop_proxy_->PostTask(
           FROM_HERE,
-          NewRunnableMethod(
-              core_.get(),
-              &NonBlockingInvalidationNotifier::Core::UpdateCredentials,
-              email, token))) {
+          base::Bind(&NonBlockingInvalidationNotifier::Core::UpdateCredentials,
+                     core_.get(), email, token))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidationNotifier::UpdateEnabledTypes(
     const syncable::ModelTypeSet& enabled_types) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   if (!io_message_loop_proxy_->PostTask(
           FROM_HERE,
-          NewRunnableMethod(
-              core_.get(),
-              &NonBlockingInvalidationNotifier::Core::UpdateEnabledTypes,
-              enabled_types))) {
+          base::Bind(&NonBlockingInvalidationNotifier::Core::UpdateEnabledTypes,
+                     core_.get(), enabled_types))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidationNotifier::SendNotification(
     const syncable::ModelTypeSet& changed_types) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   // InvalidationClient doesn't implement SendNotification(), so no
   // need to forward on the call.
 }
 
 }  // namespace sync_notifier