ChromeFrame: Convert TaskMarshallerThroughMessageQueue to new Callback system.

chrome_frame/external_tab.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 "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "chrome_frame/external_tab.h"
 #include "base/task.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome_frame/chrome_frame_delegate.h"
 #include "chrome_frame/utils.h"
 
-DISABLE_RUNNABLE_METHOD_REFCOUNT(ExternalTabProxy);
-DISABLE_RUNNABLE_METHOD_REFCOUNT(UIDelegate);
-
 namespace {
   static base::LazyInstance<ChromeProxyFactory> g_proxy_factory =
       LAZY_INSTANCE_INITIALIZER;
 
   struct UserDataHolder : public SyncMessageContext {
     explicit UserDataHolder(void* p) : data(p) {}
     void* data;
   };
 }
 
@@ skipping 81 matching lines @@
   Init();
   ui_delegate_ = delegate;
   // TODO(stoyan): Shall we check the CanNavigate(create_params.url)?
   tab_params_ = create_params;
   state_ = INIT_IN_PROGRESS;
   proxy_factory_->GetProxy(this, create_params.proxy_params);
 }
 
 void ExternalTabProxy::Connected(ChromeProxy* proxy) {
   // in ipc thread
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(this,
-      &ExternalTabProxy::UiConnected, proxy));
+  ui_.PostTask(FROM_HERE, base::Bind(&ExternalTabProxy::UiConnected,
+                                     base::Unretained(this), proxy));
 }
 
 void ExternalTabProxy::UiConnected(ChromeProxy* proxy) {
   proxy_ = proxy;
   ExternalTabSettings settings;
   settings.parent = m_hWnd;
   settings.style = WS_CHILD;
   settings.is_incognito = tab_params_.is_incognito;
   // TODO(stoyan): FIX this.
   settings.load_requests_via_automation = true;
@@ skipping 10 matching lines @@
   proxy->CreateTab(this, settings);
 }
 
 void ExternalTabProxy::Disconnected() {
   // in ipc thread
   DCHECK(done_.get() != NULL);
   done_->Signal();
 }
 
 void ExternalTabProxy::PeerLost(ChromeProxy* proxy, DisconnectReason reason) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(this, &ExternalTabProxy::UiPeerLost,
-      proxy, reason));
+  ui_.PostTask(FROM_HERE, base::Bind(&ExternalTabProxy::UiPeerLost,
+                                     base::Unretained(this), proxy, reason));
 }
 
 void ExternalTabProxy::UiPeerLost(ChromeProxy* proxy, DisconnectReason reason) {
   // TODO(stoyan):
 }
 
 void ExternalTabProxy::Navigate(const std::string& url,
     const std::string& referrer,
     NavigationConstraints* navigation_constraints) {
   // in ui thread
@@ skipping 62 matching lines @@
     if (pending_navigation_.url.is_valid())
       proxy_->Tab_Navigate(tab_, pending_navigation_.url,
                            pending_navigation_.referrer);
   }
 }
 
 void ExternalTabProxy::Completed_CreateTab(bool success, HWND chrome_wnd,
                                            HWND tab_window, int tab_handle,
                                            int session_id) {
   // in ipc_thread.
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(this,
-      &ExternalTabProxy::UiCompleted_CreateTab,
-      success, chrome_wnd, tab_window, tab_handle, session_id));
+  ui_.PostTask(
+      FROM_HERE, base::Bind(&ExternalTabProxy::UiCompleted_CreateTab,
+                            base::Unretained(this), success, chrome_wnd,
+                            tab_window, tab_handle, session_id));
 }
 
 void ExternalTabProxy::Completed_ConnectToTab(
     bool success, HWND chrome_window, HWND tab_window, int tab_handle,
     int session_id) {
   CHECK(0);
 }
 
 void ExternalTabProxy::Completed_Navigate(
     bool success, enum AutomationMsg_NavigationResponseValues res) {
   // ipc_thread;
   CHECK(0);
 }
 
 void ExternalTabProxy::OnNavigationStateChanged(
     int flags, const NavigationInfo& nav_info) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnNavigationStateChanged, flags, nav_info));
+  ui_.PostTask(FROM_HERE,
+               base::Bind(&UIDelegate::OnNavigationStateChanged,
+                          base::Unretained(ui_delegate_), flags, nav_info));
 }
 
 void ExternalTabProxy::OnUpdateTargetUrl(const std::wstring& url) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnUpdateTargetUrl, url));
+  ui_.PostTask(FROM_HERE, base::Bind(&UIDelegate::OnUpdateTargetUrl,
+                                     base::Unretained(ui_delegate_), url));
 }
 
 void ExternalTabProxy::OnTabLoaded(const GURL& url) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnLoad, url));
+  ui_.PostTask(FROM_HERE, base::Bind(&UIDelegate::OnLoad,
+                                     base::Unretained(ui_delegate_), url));
 }
 
 void ExternalTabProxy::OnMoveWindow(const gfx::Rect& pos) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnMoveWindow, pos));
+  ui_.PostTask(FROM_HERE, base::Bind(&UIDelegate::OnMoveWindow,
+                                     base::Unretained(ui_delegate_), pos));
 }
 
 void ExternalTabProxy::OnMessageToHost(const std::string& message,
                                        const std::string& origin,
                                        const std::string& target) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnMessageFromChromeFrame, message, origin, target));
+  ui_.PostTask(
+      FROM_HERE,
+      base::Bind(&UIDelegate::OnMessageFromChromeFrame,
+                 base::Unretained(ui_delegate_), message, origin, target));
 }
 
 void ExternalTabProxy::OnHandleAccelerator(const MSG& accel_message) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnHandleAccelerator, accel_message));
+  ui_.PostTask(FROM_HERE,
+               base::Bind(&UIDelegate::OnHandleAccelerator,
+                          base::Unretained(ui_delegate_), accel_message));
 }
 
 void ExternalTabProxy::OnHandleContextMenu(
     const ContextMenuModel& context_menu_model,
     int align_flags,
     const MiniContextMenuParams& params) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnHandleContextMenu, context_menu_model, align_flags,
-      params));
+  ui_.PostTask(FROM_HERE,
+               base::Bind(&UIDelegate::OnHandleContextMenu,
+                          base::Unretained(ui_delegate_), context_menu_model,
+                          align_flags, params));
 }
 
 void ExternalTabProxy::OnTabbedOut(bool reverse) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnTabbedOut, reverse));
+  ui_.PostTask(FROM_HERE, base::Bind(&UIDelegate::OnTabbedOut,
+                                     base::Unretained(ui_delegate_), reverse));
 }
 
 void ExternalTabProxy::OnGoToHistoryOffset(int offset) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnGoToHistoryOffset, offset));
+  ui_.PostTask(FROM_HERE, base::Bind(&UIDelegate::OnGoToHistoryOffset,
+                                     base::Unretained(ui_delegate_), offset));
 }
 
 void ExternalTabProxy::OnOpenURL(const GURL& url_to_open, const GURL& referrer,
                                  int open_disposition) {
-  ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
-      &UIDelegate::OnOpenURL, url_to_open, referrer, open_disposition));
+  ui_.PostTask(
+      FROM_HERE,
+      base::Bind(&UIDelegate::OnOpenURL, base::Unretained(ui_delegate_),
+                 url_to_open, referrer, open_disposition));
 }
 
 void ExternalTabProxy::OnNavigationFailed(int error_code, const GURL& gurl) {
   // TODO(stoyan):
 }
 
 void ExternalTabProxy::OnDidNavigate(const NavigationInfo& navigation_info) {
   // TODO(stoyan):
 }
 
@@ skipping 24 matching lines @@
 }
 
 void ExternalTabProxy::OnTabClosed() {
   // TODO(stoyan):
 }
 
 void ExternalTabProxy::OnAttachTab(
     const AttachExternalTabParams& attach_params) {
   // TODO(stoyan):
 }