Convert NewRunnableFunction/NewRunnableMethod calls to use base::Bind().

content/browser/browser_message_filter.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 "content/browser/browser_message_filter.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "content/browser/user_metrics.h"
 #include "content/public/common/result_codes.h"
 #include "ipc/ipc_sync_message.h"
 
 using content::BrowserThread;
 
 BrowserMessageFilter::BrowserMessageFilter()
@@ skipping 25 matching lines @@
     // but it seems better to not allow sending synchronous messages from the
     // browser, since it might allow a corrupt/malicious renderer to hang us.
     NOTREACHED() << "Can't send sync message through BrowserMessageFilter!";
     return false;
   }
 
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
-        NewRunnableMethod(this, &BrowserMessageFilter::Send, message));
+        base::IgnoreReturn<bool>(

[James Hawkins, 2011/11/14 17:57:06]

#include "base/bind_helpers.h"

[dcheng, 2011/11/14 20:47:49]

Done.

+            base::Bind(&BrowserMessageFilter::Send, this, message)));
     return true;
   }
 
   if (channel_)
     return channel_->Send(message);
 
   delete message;
   return false;
 }
 
 void BrowserMessageFilter::OverrideThreadForMessage(const IPC::Message& message,
                                                     BrowserThread::ID* thread) {
 }
 
 bool BrowserMessageFilter::OnMessageReceived(const IPC::Message& message) {
   BrowserThread::ID thread = BrowserThread::IO;
   OverrideThreadForMessage(message, &thread);
   if (thread == BrowserThread::IO)
     return DispatchMessage(message);
 
   if (thread == BrowserThread::UI && !CheckCanDispatchOnUI(message, this))
     return true;
 
   BrowserThread::PostTask(
       thread, FROM_HERE,
-      NewRunnableMethod(
-          this, &BrowserMessageFilter::DispatchMessage, message));
+      base::IgnoreReturn<bool>(
+          base::Bind(&BrowserMessageFilter::DispatchMessage, this, message)));
   return true;
 }
 
 bool BrowserMessageFilter::DispatchMessage(const IPC::Message& message) {
   bool message_was_ok = true;
   bool rv = OnMessageReceived(message, &message_was_ok);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO) || rv) <<
       "Must handle messages that were dispatched to another thread!";
   if (!message_was_ok) {
     UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_BMF"));
@@ skipping 25 matching lines @@
         "messages in the renderer or else deadlocks can occur if the page "
         "has windowed plugins! (message type " << message.type() << ")";
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     reply->set_reply_error();
     sender->Send(reply);
     return false;
   }
 #endif
   return true;
 }