base::Bind: Convert chrome_frame/.

chrome_frame/chrome_frame_automation.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/chrome_frame_automation.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
@@ skipping 172 matching lines @@
           launch_milliseconds << " ms.";
     }
   }
 
   base::Time launch_time_begin_;
 #else
   void Dump() {}
 #endif
 };
 
-DISABLE_RUNNABLE_METHOD_REFCOUNT(AutomationProxyCacheEntry);
-
 AutomationProxyCacheEntry::AutomationProxyCacheEntry(
     ChromeFrameLaunchParams* params, LaunchDelegate* delegate)
     : profile_name(params->profile_name()),
       launch_result_(AUTOMATION_LAUNCH_RESULT_INVALID) {
   DCHECK(delegate);
   thread_.reset(new base::Thread(WideToASCII(profile_name).c_str()));
   thread_->Start();
   // Use scoped_refptr so that the params will get released when the task
   // has been run.
   scoped_refptr<ChromeFrameLaunchParams> ref_params(params);
-  thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &AutomationProxyCacheEntry::CreateProxy, ref_params, delegate));
+  thread_->message_loop()->PostTask(
+      FROM_HERE, base::Bind(&AutomationProxyCacheEntry::CreateProxy,
+                            base::Unretained(this), ref_params, delegate));
 }
 
 AutomationProxyCacheEntry::~AutomationProxyCacheEntry() {
   DVLOG(1) << __FUNCTION__ << profile_name;
   // Attempt to fix chrome_frame_tests crash seen at times on the IE6/IE7
   // builders. It appears that there are cases when we can enter here when the
   // AtExitManager is tearing down the global ProxyCache which causes a crash
   // while tearing down the AutomationProxy object due to a NULL MessageLoop
   // The AutomationProxy class uses the SyncChannel which assumes the existence
   // of a MessageLoop instance.
@@ skipping 179 matching lines @@
 
 void AutomationProxyCacheEntry::OnChannelError() {
   DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
   launch_result_ = AUTOMATION_SERVER_CRASHED;
   LaunchDelegates::const_iterator it = launch_delegates_.begin();
   for (; it != launch_delegates_.end(); ++it) {
     (*it)->AutomationServerDied();
   }
 }
 
-DISABLE_RUNNABLE_METHOD_REFCOUNT(ProxyFactory);
-
 ProxyFactory::ProxyFactory() {
 }
 
 ProxyFactory::~ProxyFactory() {
   for (size_t i = 0; i < proxies_.container().size(); ++i) {
     DWORD result = proxies_[i]->WaitForThread(0);
     if (WAIT_OBJECT_0 != result)
       // TODO(stoyan): Don't leak proxies on exit.
       DLOG(ERROR) << "Proxies leaked on exit.";
   }
@@ skipping 14 matching lines @@
     }
   }
 
   if (entry == NULL) {
     DVLOG(1) << __FUNCTION__ << " creating new proxy entry";
     entry = new AutomationProxyCacheEntry(params, delegate);
     proxies_.container().push_back(entry);
   } else if (delegate) {
     // Notify the new delegate of the launch status from the worker thread
     // and add it to the list of delegates.
-    entry->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(entry.get(),
-        &AutomationProxyCacheEntry::AddDelegate, delegate));
+    entry->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&AutomationProxyCacheEntry::AddDelegate,
+                              base::Unretained(entry.get()), delegate));
   }
 
   DCHECK(automation_server_id != NULL);
   DCHECK(!entry->IsSameThread(base::PlatformThread::CurrentId()));
 
   *automation_server_id = entry;
 }
 
 bool ProxyFactory::ReleaseAutomationServer(void* server_id,
                                            LaunchDelegate* delegate) {
@@ skipping 16 matching lines @@
   lock_.Release();
 #endif
 
   // AddRef the entry object as we might need to take it out of the proxy
   // stack and then uninitialize the entry.
   entry->AddRef();
 
   bool last_delegate = false;
   if (delegate) {
     base::WaitableEvent done(true, false);
-    entry->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(entry,
-        &AutomationProxyCacheEntry::RemoveDelegate, delegate, &done,
-        &last_delegate));
+    entry->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&AutomationProxyCacheEntry::RemoveDelegate,
+                   base::Unretained(entry), delegate, &done, &last_delegate));
     done.Wait();
   }
 
   if (last_delegate) {
     lock_.Acquire();
     Vector::ContainerType::iterator it = std::find(proxies_.container().begin(),
                                                    proxies_.container().end(),
                                                    entry);
     proxies_.container().erase(it);
     lock_.Release();
@@ skipping 376 matching lines @@
             new AutomationMsg_ConnectExternalTab(external_tab_cookie_, true,
               m_hWnd, NULL, NULL, NULL, 0);
         automation_server_->SendAsAsync(message,
                                         new CreateExternalTabContext(this),
                                         this);
         DVLOG(1) << __FUNCTION__ << ": sending CreateExternalTabComplete";
       }
     }
   } else {
     // Launch failed. Note, we cannot delete proxy here.
-    PostTask(FROM_HERE, NewRunnableMethod(this,
-        &ChromeFrameAutomationClient::InitializeComplete, result));
+    PostTask(FROM_HERE,
+             base::Bind(&ChromeFrameAutomationClient::InitializeComplete, this,
+                        result));
   }
 }
 
 void ChromeFrameAutomationClient::AutomationServerDied() {
   // Make sure we notify our delegate.
-  PostTask(FROM_HERE, NewRunnableMethod(this,
-      &ChromeFrameAutomationClient::InitializeComplete,
-      AUTOMATION_SERVER_CRASHED));
+  PostTask(
+      FROM_HERE,
+      base::Bind(&ChromeFrameAutomationClient::InitializeComplete, this,
+                 AUTOMATION_SERVER_CRASHED));
   // Then uninitialize.
-  PostTask(FROM_HERE, NewRunnableMethod(this,
-      &ChromeFrameAutomationClient::Uninitialize));
+  PostTask(
+      FROM_HERE, base::Bind(&ChromeFrameAutomationClient::Uninitialize, this));
 }
 
 void ChromeFrameAutomationClient::InitializeComplete(
     AutomationLaunchResult result) {
   DCHECK_EQ(base::PlatformThread::CurrentId(), ui_thread_id_);
   if (result != AUTOMATION_SUCCESS) {
     DLOG(WARNING) << "InitializeComplete: failure " << result;
     ReleaseAutomationServer();
   } else {
     init_state_ = INITIALIZED;
@@ skipping 79 matching lines @@
     case AutomationMsg_SetCookieAsync::ID:
       if (ui_thread || (url_fetcher_flags_ &
                           PluginUrlRequestManager::COOKIE_REQUEST_THREADSAFE)) {
         AutomationMsg_SetCookieAsync::Dispatch(&msg, url_fetcher_, this,
             &PluginUrlRequestManager::SetCookiesInHost);
         return true;
       }
       break;
   }
 
-  PostTask(FROM_HERE, NewRunnableMethod(this,
-      &ChromeFrameAutomationClient::ProcessUrlRequestMessage, tab, msg, true));
+  PostTask(FROM_HERE,
+           base::Bind(&ChromeFrameAutomationClient::ProcessUrlRequestMessage,
+                      this, tab, msg, true));
   return true;
 }
 
 // These are invoked in channel's background thread.
 // Cannot call any method of the activex here since it is a STA kind of being.
 // By default we marshal the IPC message to the main/GUI thread and from there
 // we safely invoke chrome_frame_delegate_->OnMessageReceived(msg).
 bool ChromeFrameAutomationClient::OnMessageReceived(TabProxy* tab,
                                                     const IPC::Message& msg) {
   DCHECK(tab == tab_.get());
   // Quickly process network related messages.
   if (url_fetcher_ && ProcessUrlRequestMessage(tab, msg, false))
     return true;
 
   // Early check to avoid needless marshaling
   if (chrome_frame_delegate_ == NULL)
     return false;
 
-  PostTask(FROM_HERE, NewRunnableMethod(this,
-      &ChromeFrameAutomationClient::OnMessageReceivedUIThread, msg));
+  PostTask(FROM_HERE,
+           base::Bind(&ChromeFrameAutomationClient::OnMessageReceivedUIThread,
+                      this, msg));
   return true;
 }
 
 void ChromeFrameAutomationClient::OnChannelError(TabProxy* tab) {
   DCHECK(tab == tab_.get());
   // Early check to avoid needless marshaling
   if (chrome_frame_delegate_ == NULL)
     return;
 
-  PostTask(FROM_HERE, NewRunnableMethod(this,
-      &ChromeFrameAutomationClient::OnChannelErrorUIThread));
+  PostTask(
+      FROM_HERE,
+      base::Bind(&ChromeFrameAutomationClient::OnChannelErrorUIThread, this));
 }
 
 void ChromeFrameAutomationClient::OnMessageReceivedUIThread(
     const IPC::Message& msg) {
   DCHECK_EQ(base::PlatformThread::CurrentId(), ui_thread_id_);
   // Forward to the delegate.
   if (chrome_frame_delegate_)
     chrome_frame_delegate_->OnMessageReceived(msg);
 }
 
@@ skipping 11 matching lines @@
 
 void ChromeFrameAutomationClient::ReportNavigationError(
     AutomationMsg_NavigationResponseValues error_code,
     const std::string& url) {
   if (!chrome_frame_delegate_)
     return;
 
   if (ui_thread_id_ == base::PlatformThread::CurrentId()) {
     chrome_frame_delegate_->OnLoadFailed(error_code, url);
   } else {
-    PostTask(FROM_HERE, NewRunnableMethod(this,
-        &ChromeFrameAutomationClient::ReportNavigationError,
-        error_code, url));
+    PostTask(FROM_HERE,
+             base::Bind(&ChromeFrameAutomationClient::ReportNavigationError,
+                        this, error_code, url));
   }
 }
 
 void ChromeFrameAutomationClient::Resize(int width, int height,
                                          int flags) {
   if (tab_.get() && ::IsWindow(chrome_window())) {
     SetWindowPos(HWND_TOP, 0, 0, width, height, flags);
     tab_->Reposition(chrome_window(), HWND_TOP, 0, 0, width, height,
                      flags, m_hWnd);
   }
@@ skipping 192 matching lines @@
     const net::URLRequestStatus& status) {
   automation_server_->Send(new AutomationMsg_RequestEnd(
       tab_->handle(), request_id, status));
 }
 
 void ChromeFrameAutomationClient::OnCookiesRetrieved(bool success,
     const GURL& url, const std::string& cookie_string, int cookie_id) {
   automation_server_->Send(new AutomationMsg_GetCookiesHostResponse(
       tab_->handle(), success, url, cookie_string, cookie_id));
 }