base::Bind: Convert jingle/.

jingle/glue/thread_wrapper.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 "jingle/glue/thread_wrapper.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/threading/thread_local.h"
 
 namespace jingle_glue {
 
 struct JingleThreadWrapper::PendingSend {
   PendingSend(const talk_base::Message& message_value)
       : sending_thread(JingleThreadWrapper::current()),
         message(message_value),
         done_event(true, false) {
@@ skipping 129 matching lines @@
 
   PendingSend pending_send(message);
   {
     base::AutoLock auto_lock(lock_);
     pending_send_messages_.push_back(&pending_send);
   }
 
   // Need to signal |pending_send_event_| here in case the thread is
   // sending message to another thread.
   pending_send_event_.Signal();
-  message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &JingleThreadWrapper::ProcessPendingSends));
+  message_loop_->PostTask(FROM_HERE,
+                          base::Bind(&JingleThreadWrapper::ProcessPendingSends,
+                                     base::Unretained(this)));
 
 
   while (!pending_send.done_event.IsSignaled()) {
     base::WaitableEvent* events[] = {&pending_send.done_event,
                                      &current_thread->pending_send_event_};
     size_t event = base::WaitableEvent::WaitMany(events, arraysize(events));
     DCHECK(event == 0 || event == 1);
 
     if (event == 1)
       current_thread->ProcessPendingSends();
@@ skipping 29 matching lines @@
   message.phandler = handler;
   message.message_id = message_id;
   message.pdata = data;
   {
     base::AutoLock auto_lock(lock_);
     task_id = ++last_task_id_;
     messages_.insert(std::pair<int, talk_base::Message>(task_id, message));
   }
 
   if (delay_ms <= 0) {
-    message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &JingleThreadWrapper::RunTask, task_id));
+    message_loop_->PostTask(FROM_HERE,
+                            base::Bind(&JingleThreadWrapper::RunTask,
+                                       base::Unretained(this), task_id));
   } else {
-    message_loop_->PostDelayedTask(
-        FROM_HERE,
-        NewRunnableMethod(this, &JingleThreadWrapper::RunTask, task_id),
-        delay_ms);
+    message_loop_->PostDelayedTask(FROM_HERE,
+                                   base::Bind(&JingleThreadWrapper::RunTask,
+                                              base::Unretained(this), task_id),
+                                   delay_ms);
   }
 }
 
 void JingleThreadWrapper::RunTask(int task_id) {
   bool have_message = false;
   talk_base::Message message;
   {
     base::AutoLock auto_lock(lock_);
     MessagesQueue::iterator it = messages_.find(task_id);
     if (it != messages_.end()) {
@@ skipping 58 matching lines @@
 
 void JingleThreadWrapper::Stop() {
   NOTREACHED();
 }
 
 void JingleThreadWrapper::Run() {
   NOTREACHED();
 }
 
 }  // namespace jingle_glue