base::Bind() conversion for content/common/gpu and content/gpu

content/common/gpu/gpu_channel.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "content/common/child_process.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/transport_texture.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
@@ skipping 11 matching lines @@
     : gpu_channel_manager_(gpu_channel_manager),
       renderer_id_(renderer_id),
       renderer_process_(base::kNullProcessHandle),
       renderer_pid_(base::kNullProcessId),
       share_group_(new gfx::GLShareGroup),
       watchdog_(watchdog),
       software_(software),
       handle_messages_scheduled_(false),
       processed_get_state_fast_(false),
       num_contexts_preferring_discrete_gpu_(0),
-      task_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(gpu_channel_manager);
   DCHECK(renderer_id);
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
   disallowed_features_.multisampling =
       command_line->HasSwitch(switches::kDisableGLMultisampling);
   disallowed_features_.driver_bug_workarounds =
       command_line->HasSwitch(switches::kDisableGpuDriverBugWorkarounds);
 }
 
@@ skipping 97 matching lines @@
 void GpuChannel::OnScheduled() {
   if (handle_messages_scheduled_)
     return;
   // Post a task to handle any deferred messages. The deferred message queue is
   // not emptied here, which ensures that OnMessageReceived will continue to
   // defer newly received messages until the ones in the queue have all been
   // handled by HandleDeferredMessages. HandleDeferredMessages is invoked as a
   // task to prevent reentrancy.
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      task_factory_.NewRunnableMethod(
-          &GpuChannel::HandleMessage));
+      base::Bind(&GpuChannel::HandleMessage, weak_factory_.GetWeakPtr()));
   handle_messages_scheduled_ = true;
 }
 
 void GpuChannel::LoseAllContexts() {
   gpu_channel_manager_->LoseAllContexts();
 }
 
 void GpuChannel::DestroySoon() {
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableMethod(this,
-          &GpuChannel::OnDestroy));
+      FROM_HERE, base::Bind(&GpuChannel::OnDestroy, this));
 }
 
 void GpuChannel::OnDestroy() {
   TRACE_EVENT0("gpu", "GpuChannel::OnDestroy");
   gpu_channel_manager_->RemoveChannel(renderer_id_);
 }
 
 void GpuChannel::CreateViewCommandBuffer(
     gfx::PluginWindowHandle window,
     int32 render_view_id,
@@ skipping 276 matching lines @@
 
 #if defined(OS_POSIX)
 int GpuChannel::TakeRendererFileDescriptor() {
   if (!channel_.get()) {
     NOTREACHED();
     return -1;
   }
   return channel_->TakeClientFileDescriptor();
 }
 #endif  // defined(OS_POSIX)