ChromeFrame: Convert TaskMarshallerThroughMessageQueue to new Callback system.

chrome_frame/cfproxy_proxy.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_frame/cfproxy_private.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/tuple.h"
 #include "ipc/ipc_sync_message.h"
 #include "chrome/common/automation_messages.h"
 
 CFProxy::CFProxy(CFProxyTraits* api) : ipc_thread_("ipc"),
                                        sync_dispatcher_(&tab2delegate_),
                                        ipc_sender_(NULL),
                                        api_(api),
                                        delegate_count_(0),
                                        is_connected_(false) {
 }
 
 CFProxy::~CFProxy() {
-  ipc_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &CFProxy::CleanupOnIoThread));
+  ipc_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CFProxy::CleanupOnIoThread, base::Unretained(this)));
   // ipc_thread destructor will do the Stop anyway. this is for debug :)
   ipc_thread_.Stop();
 }
 
-
 void CFProxy::Init(const ProxyParams& params) {
   ipc_thread_.StartWithOptions(base::Thread::Options(MessageLoop::TYPE_IO, 0));
-  ipc_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &CFProxy::InitInIoThread, params));
+  ipc_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CFProxy::InitInIoThread, base::Unretained(this), params));
 }
 
 int CFProxy::AddDelegate(ChromeProxyDelegate* delegate) {
-  ipc_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &CFProxy::AddDelegateOnIoThread, delegate));
+  ipc_thread_.message_loop()->PostTask(
+      FROM_HERE, base::Bind(&CFProxy::AddDelegateOnIoThread,
+                            base::Unretained(this), delegate));
   return ++delegate_count_;
 }
 
 int CFProxy::RemoveDelegate(ChromeProxyDelegate* delegate) {
-  ipc_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &CFProxy::RemoveDelegateOnIoThread, delegate));
+  ipc_thread_.message_loop()->PostTask(
+      FROM_HERE, base::Bind(&CFProxy::RemoveDelegateOnIoThread,
+                            base::Unretained(this), delegate));
   return --delegate_count_;
 }
 
 void CFProxy::AddDelegateOnIoThread(ChromeProxyDelegate* delegate) {
   DCHECK(CalledOnIpcThread());
   DelegateHolder::AddDelegate(delegate);
   if (is_connected_) {
     delegate->Connected(this);
   }
 }
 
 void CFProxy::RemoveDelegateOnIoThread(ChromeProxyDelegate* delegate) {
   DCHECK(CalledOnIpcThread());
   // Cancel any calls in progress.
   sync_dispatcher_.Cancel(delegate);
   DelegateHolder::RemoveDelegate(delegate);
   delegate->Disconnected();
 }
 
 void CFProxy::InitInIoThread(const ProxyParams& params) {
   DCHECK(CalledOnIpcThread());
   std::string channel_id = GenerateChannelId();
   ipc_sender_ = api_->CreateChannel(channel_id, this);
   std::wstring cmd_line = BuildCmdLine(channel_id, params.profile_path,
                                        params.extra_params);
   if (!cmd_line.empty() && api_->LaunchApp(cmd_line)) {
-    CancelableTask* launch_timeout = NewRunnableMethod(this,
-        &CFProxy::LaunchTimeOut);
-    ipc_thread_.message_loop()->PostDelayedTask(FROM_HERE, launch_timeout,
+    ipc_thread_.message_loop()->PostDelayedTask(
+        FROM_HERE, base::Bind(&CFProxy::LaunchTimeOut, base::Unretained(this)),
         params.timeout.InMilliseconds());
   } else {
     OnPeerLost(ChromeProxyDelegate::CHROME_EXE_LAUNCH_FAILED);
   }
 }
 
 void CFProxy::CleanupOnIoThread() {
   DCHECK(CalledOnIpcThread());
   if (ipc_sender_) {
     api_->CloseChannel(ipc_sender_);
@@ skipping 22 matching lines @@
     ipc_sender_ = NULL;
   }
 
   for (DelegateList::iterator it = delegate_list_.begin();
        it != delegate_list_.end(); ++it) {
     (*it)->PeerLost(this, reason);
   }
 }
 
 void CFProxy::SendIpcMessage(IPC::Message* m) {
-  ipc_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &CFProxy::SendIpcMessageOnIoThread, m));
+  ipc_thread_.message_loop()->PostTask(
+      FROM_HERE, base::Bind(&CFProxy::SendIpcMessageOnIoThread,
+                            base::Unretained(this), m));
 }
 
 void CFProxy::SendIpcMessageOnIoThread(IPC::Message* m) {
   DCHECK(CalledOnIpcThread());
   if (ipc_sender_) {
     ipc_sender_->Send(m);
   } else {
     delete m;
   }
 }
@@ skipping 87 matching lines @@
 void CFProxy::OnChannelError() {
   is_connected_ = false;
 
   // Inform the sync message callbacks that there are not going to see
   // any reply.
   sync_dispatcher_.OnChannelClosed();
   OnPeerLost(ChromeProxyDelegate::CHANNEL_ERROR);
 
   // TODO(stoyan): Relaunch?
 }