base::Bind: Cleanup in automation.

chrome/browser/automation/ui_controls_mac.mm

 // 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"
 
 #import <Cocoa/Cocoa.h>
 #include <mach/mach_time.h>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/message_loop.h"
 #include "chrome/browser/automation/ui_controls_internal.h"
 #include "content/browser/browser_thread.h"
 #include "ui/base/keycodes/keyboard_code_conversion_mac.h"
 
 // Implementation details: We use [NSApplication sendEvent:] instead
 // of [NSApplication postEvent:atStart:] so that the event gets sent
 // immediately.  This lets us run the post-event task right
 // immediately as well.  Unfortunately I cannot subclass NSEvent (it's
 // probably a class cluster) to allow other easy answers.  For
@@ skipping 159 matching lines @@
     events->push_back(event);
   }
   if (control) {
     flags &= ~NSControlKeyMask;
     event = SynthesizeKeyEvent(window, false, ui::VKEY_CONTROL, flags);
     DCHECK(event);
     events->push_back(event);
   }
 }
 
-// A task class to watch for the event queue. The specific task will be fired
-// when there is no more event in the queue.
-class EventQueueWatcher : public Task {
- public:
-  EventQueueWatcher(Task* task) : task_(task) {}
-
-  virtual ~EventQueueWatcher() {}
-
-  virtual void Run() {
-    NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
-                                        untilDate:nil
-                                           inMode:NSDefaultRunLoopMode
-                                          dequeue:NO];
-    // If there is still event in the queue, then we need to check again.
-    if (event)
-      MessageLoop::current()->PostTask(FROM_HERE, new EventQueueWatcher(task_));
-    else
-      MessageLoop::current()->PostTask(FROM_HERE, task_);
+// A helper function to watch for the event queue. The specific task will be
+// fired when there is no more event in the queue.
+void EventQueueWatcher(const base::Closure& task) {
+  NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
+                                      untilDate:nil
+                                         inMode:NSDefaultRunLoopMode
+                                        dequeue:NO];
+  // If there is still event in the queue, then we need to check again.
+  if (event) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&EventQueueWatcher, task));
+  } else {
+    MessageLoop::current()->PostTask(FROM_HERE, task);
   }
-
- private:
-  Task* task_;
-};
+}
 
 // Stores the current mouse location on the screen. So that we can use it
 // when firing keyboard and mouse click events.
 NSPoint g_mouse_location = { 0, 0 };
 
 }  // anonymous namespace
 
-
 namespace ui_controls {
 
 bool SendKeyPress(gfx::NativeWindow window,
                   ui::KeyboardCode key,
                   bool control,
                   bool shift,
                   bool alt,
                   bool command) {
   return SendKeyPressNotifyWhenDone(window, key,
                                     control, shift, alt, command,
-                                    NULL);
+                                    base::Closure());
 }
 
 // Win and Linux implement a SendKeyPress() this as a
 // SendKeyPressAndRelease(), so we should as well (despite the name).
 bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
                                 ui::KeyboardCode key,
                                 bool control,
                                 bool shift,
                                 bool alt,
                                 bool command,
-                                Task* task) {
+                                const base::Closure& task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::vector<NSEvent*> events;
   SynthesizeKeyEventsSequence(
       window, key, control, shift, alt, command, &events);
 
   // TODO(suzhe): Using [NSApplication postEvent:atStart:] here causes
   // BrowserKeyEventsTest.CommandKeyEvents to fail. See http://crbug.com/49270
   // But using [NSApplication sendEvent:] should be safe for keyboard events,
   // because until now, no code wants to retrieve the next event when handling
   // a keyboard event.
   for (std::vector<NSEvent*>::iterator iter = events.begin();
        iter != events.end(); ++iter)
     [[NSApplication sharedApplication] sendEvent:*iter];
 
-  if (task)
-    MessageLoop::current()->PostTask(FROM_HERE, new EventQueueWatcher(task));
+  if (!task.is_null()) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&EventQueueWatcher, task));
+  }
 
   return true;
 }
 
 bool SendMouseMove(long x, long y) {
-  return SendMouseMoveNotifyWhenDone(x, y, NULL);
+  return SendMouseMoveNotifyWhenDone(x, y, base::Closure());
 }
 
 // Input position is in screen coordinates.  However, NSMouseMoved
 // events require them window-relative, so we adjust.  We *DO* flip
 // the coordinate space, so input events can be the same for all
 // platforms.  E.g. (0,0) is upper-left.
-bool SendMouseMoveNotifyWhenDone(long x, long y, Task* task) {
+bool SendMouseMoveNotifyWhenDone(long x, long y, const base::Closure& task) {
   NSWindow* window = [[NSApplication sharedApplication] keyWindow];
   CGFloat screenHeight =
     [[[NSScreen screens] objectAtIndex:0] frame].size.height;
   g_mouse_location = NSMakePoint(x, screenHeight - y);  // flip!
   NSPoint pointInWindow = g_mouse_location;
   if (window)
     pointInWindow = [window convertScreenToBase:pointInWindow];
   NSTimeInterval timestamp = TimeIntervalSinceSystemStartup();
 
   NSEvent* event =
       [NSEvent mouseEventWithType:NSMouseMoved
                          location:pointInWindow
                     modifierFlags:0
                         timestamp:timestamp
                      windowNumber:[window windowNumber]
                           context:nil
                       eventNumber:0
                        clickCount:0
                          pressure:0.0];
   [[NSApplication sharedApplication] postEvent:event atStart:NO];
 
-  if (task)
-    MessageLoop::current()->PostTask(FROM_HERE, new EventQueueWatcher(task));
+  if (!task.is_null()) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&EventQueueWatcher, task));
+  }
 
   return true;
 }
 
 bool SendMouseEvents(MouseButton type, int state) {
-  return SendMouseEventsNotifyWhenDone(type, state, NULL);
+  return SendMouseEventsNotifyWhenDone(type, state, base::Closure());
 }
 
-bool SendMouseEventsNotifyWhenDone(MouseButton type, int state, Task* task) {
+bool SendMouseEventsNotifyWhenDone(MouseButton type, int state,
+                                   const base::Closure& task) {
   // On windows it appears state can be (UP|DOWN).  It is unclear if
   // that'll happen here but prepare for it just in case.
   if (state == (UP|DOWN)) {
-    return (SendMouseEventsNotifyWhenDone(type, DOWN, NULL) &&
+    return (SendMouseEventsNotifyWhenDone(type, DOWN, base::Closure()) &&
             SendMouseEventsNotifyWhenDone(type, UP, task));
   }
   NSEventType etype = 0;
   if (type == LEFT) {
     if (state == UP) {
       etype = NSLeftMouseUp;
     } else {
       etype = NSLeftMouseDown;
     }
   } else if (type == MIDDLE) {
@@ skipping 21 matching lines @@
                          location:pointInWindow
                     modifierFlags:0
                         timestamp:TimeIntervalSinceSystemStartup()
                      windowNumber:[window windowNumber]
                           context:nil
                       eventNumber:0
                        clickCount:1
                          pressure:(state == DOWN ? 1.0 : 0.0 )];
   [[NSApplication sharedApplication] postEvent:event atStart:NO];
 
-  if (task)
-    MessageLoop::current()->PostTask(FROM_HERE, new EventQueueWatcher(task));
+  if (!task.is_null()) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&EventQueueWatcher, task));
+  }
 
   return true;
 }
 
 bool SendMouseClick(MouseButton type) {
- return SendMouseEventsNotifyWhenDone(type, UP|DOWN, NULL);
+ return SendMouseEventsNotifyWhenDone(type, UP|DOWN, base::Closure());
 }
 
 void MoveMouseToCenterAndPress(
     NSView* view,
     MouseButton button,
     int state,
-    Task* task) {
+    const base::Closure& task) {
   DCHECK(view);
   NSWindow* window = [view window];
   DCHECK(window);
   NSScreen* screen = [window screen];
   DCHECK(screen);
 
   // Converts the center position of the view into the coordinates accepted
   // by SendMouseMoveNotifyWhenDone() method.
   NSRect bounds = [view bounds];
   NSPoint center = NSMakePoint(NSMidX(bounds), NSMidY(bounds));
   center = [view convertPoint:center toView:nil];
   center = [window convertBaseToScreen:center];
   center = NSMakePoint(center.x, [screen frame].size.height - center.y);
 
-  SendMouseMoveNotifyWhenDone(center.x, center.y,
-                              new ClickTask(button, state, task));
+  SendMouseMoveNotifyWhenDone(
+      center.x, center.y,
+      base::Bind(&ui_controls::ClickTask, button, state, task));
 }
 
 }  // ui_controls