base::Bind: Convert content/renderer.

content/renderer/gpu/gpu_channel_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 "content/renderer/gpu/gpu_channel_host.h"
 
+#include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "content/common/child_process.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/renderer/gpu/command_buffer_proxy.h"
 #include "content/renderer/gpu/transport_texture_service.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_sync_message_filter.h"
@@ skipping 55 matching lines @@
     return false;
 
   DCHECK(message.routing_id() != MSG_ROUTING_CONTROL);
 
   ListenerMap::iterator it = listeners_.find(message.routing_id());
 
   if (it != listeners_.end()) {
     const scoped_refptr<GpuChannelHost::Listener>& listener = it->second;
     listener->loop()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(
-            listener.get(),
-            &GpuChannelHost::Listener::DispatchMessage,
-            message));
+        base::Bind(&GpuChannelHost::Listener::DispatchMessage, listener.get(),
+                   message));
   }
 
   return true;
 }
 
 void GpuChannelHost::MessageFilter::OnChannelError() {
   DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
   // Inform all the proxies that an error has occurred. This will be reported
   // via OpenGL as a lost context.
   for (ListenerMap::iterator it = listeners_.begin();
        it != listeners_.end();
        it++) {
     const scoped_refptr<GpuChannelHost::Listener>& listener = it->second;
     listener->loop()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(
-            listener.get(),
-            &GpuChannelHost::Listener::DispatchError));
+        base::Bind(&GpuChannelHost::Listener::DispatchError, listener.get()));
   }
 
   listeners_.clear();
 
   ChildThread* main_thread = RenderProcess::current()->main_thread();
   MessageLoop* main_loop = main_thread->message_loop();
   main_loop->PostTask(FROM_HERE,
-                      NewRunnableMethod(parent_,
-                                        &GpuChannelHost::OnChannelError));
+                      base::Bind(&GpuChannelHost::OnChannelError, parent_));
 }
 
 GpuChannelHost::GpuChannelHost()
     : state_(kUnconnected),
       transport_texture_service_(new TransportTextureService()) {
 }
 
 GpuChannelHost::~GpuChannelHost() {
 }
 
@@ skipping 182 matching lines @@
   delete command_buffer;
 #endif
 }
 
 void GpuChannelHost::AddRoute(
     int route_id, base::WeakPtr<IPC::Channel::Listener> listener) {
   DCHECK(MessageLoopProxy::current());
 
   MessageLoopProxy* io_loop = RenderProcess::current()->io_message_loop_proxy();
   io_loop->PostTask(FROM_HERE,
-                    NewRunnableMethod(
-                        channel_filter_.get(),
-                        &GpuChannelHost::MessageFilter::AddRoute,
-                        route_id, listener, MessageLoopProxy::current()));
+                    base::Bind(&GpuChannelHost::MessageFilter::AddRoute,
+                               channel_filter_.get(), route_id, listener,
+                               MessageLoopProxy::current()));
 }
 
 void GpuChannelHost::RemoveRoute(int route_id) {
   MessageLoopProxy* io_loop = RenderProcess::current()->io_message_loop_proxy();
   io_loop->PostTask(FROM_HERE,
-                    NewRunnableMethod(
-                        channel_filter_.get(),
-                        &GpuChannelHost::MessageFilter::RemoveRoute,
-                        route_id));
+                    base::Bind(&GpuChannelHost::MessageFilter::RemoveRoute,
+                               channel_filter_.get(), route_id));
 }
 
 bool GpuChannelHost::WillGpuSwitchOccur(
     bool is_creating_context, gfx::GpuPreference gpu_preference) {
   bool result = false;
   if (!Send(new GpuChannelMsg_WillGpuSwitchOccur(is_creating_context,
                                                  gpu_preference,
                                                  &result))) {
     return false;
   }
   return result;
 }
 
 void GpuChannelHost::ForciblyCloseChannel() {
   Send(new GpuChannelMsg_CloseChannel());
   SetStateLost();
 }