base::Bind: Cleanup in automation.

chrome/browser/automation/ui_controls_win.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/browser/automation/ui_controls.h"
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/keycodes/keyboard_code_conversion_win.h"
 #include "views/view.h"
 
 namespace ui_controls {
 
 namespace {
 
 // InputDispatcher ------------------------------------------------------------
 
 // InputDispatcher is used to listen for a mouse/keyboard event. When the
 // appropriate event is received the task is notified.
 class InputDispatcher : public base::RefCounted<InputDispatcher> {
  public:
-  InputDispatcher(Task* task, WPARAM message_waiting_for);
+  InputDispatcher(base::Closure& task, WPARAM message_waiting_for);
 
   // Invoked from the hook. If mouse_message matches message_waiting_for_
   // MatchingMessageFound is invoked.
   void DispatchedMessage(WPARAM mouse_message);
 
   // Invoked when a matching event is found. Uninstalls the hook and schedules
   // an event that notifies the task.
   void MatchingMessageFound();
 
  private:
   friend class base::RefCounted<InputDispatcher>;
 
   ~InputDispatcher();
 
   // Notifies the task and release this (which should delete it).
   void NotifyTask();
 
   // The task we notify.
-  scoped_ptr<Task> task_;
+  base::Closure task_;
 
   // Message we're waiting for. Not used for keyboard events.
   const WPARAM message_waiting_for_;
 
   DISALLOW_COPY_AND_ASSIGN(InputDispatcher);
 };
 
 // Have we installed the hook?
 bool installed_hook_ = false;
 
@@ skipping 45 matching lines @@
 
 // Uninstalls the hook set in InstallHook.
 void UninstallHook(InputDispatcher* dispatcher) {
   if (current_dispatcher_ == dispatcher) {
     installed_hook_ = false;
     current_dispatcher_ = NULL;
     UnhookWindowsHookEx(next_hook_);
   }
 }
 
-InputDispatcher::InputDispatcher(Task* task, UINT message_waiting_for)
+InputDispatcher::InputDispatcher(const base::Closure& task,
+                                 UINT message_waiting_for)
     : task_(task), message_waiting_for_(message_waiting_for) {
   InstallHook(this, message_waiting_for == WM_KEYUP);
 }
 
 InputDispatcher::~InputDispatcher() {
   // Make sure the hook isn't installed.
   UninstallHook(this);
 }
 
 void InputDispatcher::DispatchedMessage(WPARAM message) {
   if (message == message_waiting_for_)
     MatchingMessageFound();
 }
 
 void InputDispatcher::MatchingMessageFound() {
   UninstallHook(this);
   // At the time we're invoked the event has not actually been processed.
   // Use PostTask to make sure the event has been processed before notifying.
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, NewRunnableMethod(this, &InputDispatcher::NotifyTask), 0);
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&InputDispatcher::NotifyTask, this));
 }
 
 void InputDispatcher::NotifyTask() {
-  task_->Run();
+  task_.Run();
   Release();
 }
 
 // Private functions ----------------------------------------------------------
 
 // Populate the INPUT structure with the appropriate keyboard event
 // parameters required by SendInput
 bool FillKeyboardInput(ui::KeyboardCode key, INPUT* input, bool key_up) {
   memset(input, 0, sizeof(INPUT));
   input->type = INPUT_KEYBOARD;
@@ skipping 12 matching lines @@
     return false;
 
   if (!::SendInput(1, &input, sizeof(INPUT)))
     return false;
 
   return true;
 }
 
 bool SendKeyPressImpl(ui::KeyboardCode key,
                       bool control, bool shift, bool alt,
-                      Task* task) {
+                      const base::Closure& task) {
   scoped_refptr<InputDispatcher> dispatcher(
-      task ? new InputDispatcher(task, WM_KEYUP) : NULL);
+      !task.is_null() ? new InputDispatcher(task, WM_KEYUP) : NULL);
 
   // If a pop-up menu is open, it won't receive events sent using SendInput.
   // Check for a pop-up menu using its window class (#32768) and if one
   // exists, send the key event directly there.
   HWND popup_menu = ::FindWindow(L"#32768", 0);
   if (popup_menu != NULL && popup_menu == ::GetTopWindow(NULL)) {
     WPARAM w_param = ui::WindowsKeyCodeForKeyboardCode(key);
     LPARAM l_param = 0;
     ::SendMessage(popup_menu, WM_KEYDOWN, w_param, l_param);
     ::SendMessage(popup_menu, WM_KEYUP, w_param, l_param);
@@ skipping 52 matching lines @@
 
   if (::SendInput(i, input, sizeof(INPUT)) != i)
     return false;
 
   if (dispatcher.get())
     dispatcher->AddRef();
 
   return true;
 }
 
-bool SendMouseMoveImpl(long x, long y, Task* task) {
+bool SendMouseMoveImpl(long x, long y, const base::Closure& task) {
   // First check if the mouse is already there.
   POINT current_pos;
   ::GetCursorPos(&current_pos);
   if (x == current_pos.x && y == current_pos.y) {
-    if (task)
+    if (!task.is_null())
       MessageLoop::current()->PostTask(FROM_HERE, task);
     return true;
   }
 
   INPUT input = { 0 };
 
   int screen_width = ::GetSystemMetrics(SM_CXSCREEN) - 1;
   int screen_height  = ::GetSystemMetrics(SM_CYSCREEN) - 1;
   LONG pixel_x  = static_cast<LONG>(x * (65535.0f / screen_width));
   LONG pixel_y = static_cast<LONG>(y * (65535.0f / screen_height));
 
   input.type = INPUT_MOUSE;
   input.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE;
   input.mi.dx = pixel_x;
   input.mi.dy = pixel_y;
 
   scoped_refptr<InputDispatcher> dispatcher(
-      task ? new InputDispatcher(task, WM_MOUSEMOVE) : NULL);
+      !task.is_null() ? new InputDispatcher(task, WM_MOUSEMOVE) : NULL);
 
   if (!::SendInput(1, &input, sizeof(INPUT)))
     return false;
 
   if (dispatcher.get())
     dispatcher->AddRef();
 
   return true;
 }
 
-bool SendMouseEventsImpl(MouseButton type, int state, Task* task) {
+bool SendMouseEventsImpl(MouseButton type, int state,
+                         const base::Closure& task) {
   DWORD down_flags = MOUSEEVENTF_ABSOLUTE;
   DWORD up_flags = MOUSEEVENTF_ABSOLUTE;
   UINT last_event;
 
   switch (type) {
     case LEFT:
       down_flags |= MOUSEEVENTF_LEFTDOWN;
       up_flags |= MOUSEEVENTF_LEFTUP;
       last_event = (state & UP) ? WM_LBUTTONUP : WM_LBUTTONDOWN;
       break;
 
     case MIDDLE:
       down_flags |= MOUSEEVENTF_MIDDLEDOWN;
       up_flags |= MOUSEEVENTF_MIDDLEUP;
       last_event = (state & UP) ? WM_MBUTTONUP : WM_MBUTTONDOWN;
       break;
 
     case RIGHT:
       down_flags |= MOUSEEVENTF_RIGHTDOWN;
       up_flags |= MOUSEEVENTF_RIGHTUP;
       last_event = (state & UP) ? WM_RBUTTONUP : WM_RBUTTONDOWN;
       break;
 
     default:
       NOTREACHED();
       return false;
   }
 
   scoped_refptr<InputDispatcher> dispatcher(
-      task ? new InputDispatcher(task, last_event) : NULL);
+      !task.is_null() ? new InputDispatcher(task, last_event) : NULL);
 
   INPUT input = { 0 };
   input.type = INPUT_MOUSE;
   input.mi.dwFlags = down_flags;
   if ((state & DOWN) && !::SendInput(1, &input, sizeof(INPUT)))
     return false;
 
   input.mi.dwFlags = up_flags;
   if ((state & UP) && !::SendInput(1, &input, sizeof(INPUT)))
     return false;
 
   if (dispatcher.get())
     dispatcher->AddRef();
 
   return true;
 }
 
 }  // namespace
 
 // public functions -----------------------------------------------------------
 
 bool SendKeyPress(gfx::NativeWindow window,
                   ui::KeyboardCode key,
                   bool control,
                   bool shift,
                   bool alt,
                   bool command) {
   DCHECK(!command);  // No command key on Windows
-  return SendKeyPressImpl(key, control, shift, alt, NULL);
+  return SendKeyPressImpl(key, control, shift, alt, base::Closure());
 }
 
 bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
                                 ui::KeyboardCode key,
                                 bool control,
                                 bool shift,
                                 bool alt,
                                 bool command,
-                                Task* task) {
+                                const base::Closure& task) {
   DCHECK(!command);  // No command key on Windows
   return SendKeyPressImpl(key, control, shift, alt, task);
 }
 
 bool SendMouseMove(long x, long y) {
-  return SendMouseMoveImpl(x, y, NULL);
+  return SendMouseMoveImpl(x, y, base::Closure());
 }
 
-bool SendMouseMoveNotifyWhenDone(long x, long y, Task* task) {
+bool SendMouseMoveNotifyWhenDone(long x, long y, const base::Closure& task) {
   return SendMouseMoveImpl(x, y, task);
 }
 
 bool SendMouseEvents(MouseButton type, int state) {
-  return SendMouseEventsImpl(type, state, NULL);
+  return SendMouseEventsImpl(type, state, base::Closure());
 }
 
-bool SendMouseEventsNotifyWhenDone(MouseButton type, int state, Task* task) {
+bool SendMouseEventsNotifyWhenDone(MouseButton type, int state,
+                                   base::Closure& task) {

[awong, 2011/10/11 01:18:04]

const base::Closure&

[James Hawkins, 2011/10/11 21:11:22]

Done.

   return SendMouseEventsImpl(type, state, task);
 }
 
 bool SendMouseClick(MouseButton type) {
-  return SendMouseEventsImpl(type, UP | DOWN, NULL);
+  return SendMouseEventsImpl(type, UP | DOWN, base::Closure());
 }
 
 void MoveMouseToCenterAndPress(views::View* view,
                                MouseButton button,
                                int state,
-                               Task* task) {
+                               base::Closure& task) {
   DCHECK(view);
   DCHECK(view->GetWidget());
   gfx::Point view_center(view->width() / 2, view->height() / 2);
   views::View::ConvertPointToScreen(view, &view_center);
   SendMouseMove(view_center.x(), view_center.y());
   SendMouseEventsNotifyWhenDone(button, state, task);
 }
 
 }  // ui_controls