base::Bind: Cleanup in automation.

chrome/browser/automation/automation_provider_gtk.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/automation_provider.h"
 
 #include <gtk/gtk.h>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/automation/automation_browser_tracker.h"
 #include "chrome/browser/automation/automation_window_tracker.h"
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/view_id_util.h"
 #include "chrome/common/automation_messages.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 
+namespace {
+
+// This function sends a WindowDragResponse message with the appropriate routing
+// ID to the automation proxy.
+void WindowDragResponse(AutomationProvider* provider,
+                        IPC::Message* reply_message) {
+  AutomationMsg_WindowDrag::WriteReplyParams(reply_message, true);
+  provider->Send(reply_message);
+}
+
+// TODO(jhawkins): Get rid of these functions once base::Bind supports functions
+// with non-void return values.
+void SendMouseEventsNotifyWhenDoneWithoutResult(
+    ui_controls::MouseButton type, int state, const base::Closure& task) {
+  ui_controls::SendMouseEventsNotifyWhenDone(type, state, task);
+}
+
+void SendMouseMoveNotifyWhenDoneWithoutResult(
+    long x, long y, const base::Closure& task) {
+  ui_controls::SendMouseMoveNotifyWhenDone(x, y, task);
+}
+
+}  // namespace
+
 void AutomationProvider::PrintAsync(int tab_handle) {
   NOTIMPLEMENTED();
 }
 
-// This task sends a WindowDragResponse message with the appropriate
-// routing ID to the automation proxy.  This is implemented as a task so that
-// we know that the mouse events (and any tasks that they spawn on the message
-// loop) have been processed by the time this is sent.
-class WindowDragResponseTask : public Task {
- public:
-  WindowDragResponseTask(AutomationProvider* provider,
-                         IPC::Message* reply_message)
-      : provider_(provider),
-        reply_message_(reply_message) {
-    DCHECK(provider_);
-    DCHECK(reply_message_);
-  }
-
-  virtual ~WindowDragResponseTask() {
-  }
-
-  virtual void Run() {
-    AutomationMsg_WindowDrag::WriteReplyParams(reply_message_, true);
-    provider_->Send(reply_message_);
-  }
-
- private:
-  AutomationProvider* provider_;
-  IPC::Message* reply_message_;
-
-  DISALLOW_COPY_AND_ASSIGN(WindowDragResponseTask);
-};
-
-// A task that just runs a SendMouseEvent and performs another task when done.
-class MouseEventTask : public Task {
- public:
-  MouseEventTask(Task* next_task, ui_controls::MouseButtonState state)
-      : next_task_(next_task),
-        state_(state) {}
-
-  virtual ~MouseEventTask() {
-  }
-
-  virtual void Run() {
-    ui_controls::SendMouseEventsNotifyWhenDone(ui_controls::LEFT, state_,
-                                               next_task_);
-  }
-
- private:
-  // The task to execute when we are done.
-  Task* next_task_;
-
-  // Mouse press or mouse release.
-  ui_controls::MouseButtonState state_;
-
-  DISALLOW_COPY_AND_ASSIGN(MouseEventTask);
-};
-
-// A task that just runs a SendMouseMove and performs another task when done.
-class MouseMoveTask : public Task {
- public:
-  MouseMoveTask(Task* next_task, int absolute_x, int absolute_y)
-      : next_task_(next_task),
-        x_(absolute_x),
-        y_(absolute_y) {
-  }
-
-  virtual ~MouseMoveTask() {
-  }
-
-  virtual void Run() {
-    ui_controls::SendMouseMoveNotifyWhenDone(x_, y_, next_task_);
-  }
-
- private:
-  // The task to execute when we are done.
-  Task* next_task_;
-
-  // Coordinates of the press.
-  int x_;
-  int y_;
-
-  DISALLOW_COPY_AND_ASSIGN(MouseMoveTask);
-};
-
 void AutomationProvider::WindowSimulateDrag(
     int handle,
     const std::vector<gfx::Point>& drag_path,
     int flags,
     bool press_escape_en_route,
     IPC::Message* reply_message) {
   // TODO(estade): don't ignore |flags| or |escape_en_route|.
   gfx::NativeWindow window =
       browser_tracker_->GetResource(handle)->window()->GetNativeHandle();
   if (window && (drag_path.size() > 1)) {
     int x, y;
     gdk_window_get_position(GTK_WIDGET(window)->window, &x, &y);
 
     // Create a nested stack of tasks to run.
-    Task* next_task = new WindowDragResponseTask(this, reply_message);
-    next_task = new MouseEventTask(next_task, ui_controls::UP);
-    next_task = new MouseEventTask(next_task, ui_controls::UP);
+    base::Closure task1 = base::Bind(&WindowDragResponse,
+                                     make_scoped_refptr(this), reply_message);
+    base::Closure task2 =
+        base::Bind(&SendMouseEventsNotifyWhenDoneWithoutResult,
+                   ui_controls::LEFT, ui_controls::UP, task1);
+    base::Closure task3 =
+        base::Bind(&SendMouseEventsNotifyWhenDoneWithoutResult,
+                   ui_controls::LEFT, ui_controls::UP, task2);
+    base::Closure task4, task5;
+    base::Closure* task = &task3;
     for (size_t i = drag_path.size() - 1; i > 0; --i) {
       // Smooth out the mouse movements by adding intermediate points. This
       // better simulates a real user drag.
       int dest_x = drag_path[i].x() + x;
       int dest_y = drag_path[i].y() + y;
       int half_step_x = (dest_x + drag_path[i - 1].x() + x) / 2;
       int half_step_y = (dest_y + drag_path[i - 1].y() + y) / 2;
 
-      next_task = new MouseMoveTask(next_task, dest_x, dest_y);
-      next_task = new MouseMoveTask(next_task, half_step_x, half_step_y);
+      task4 = base::Bind(&SendMouseMoveNotifyWhenDoneWithoutResult, dest_x,
+                         dest_y, *task);
+      task5 = base::Bind(&SendMouseMoveNotifyWhenDoneWithoutResult, half_step_x,
+                         half_step_y, task4);
+      task = &task5;

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

Why bother with a task* at all?  Just copy?

In fact, I'd rename a bunch of these.

task1 -> drag_response_cb

base::Closure move_chain_cb = IgnoreResult<bool>(
    base::Bind(&ui_controls::SendMouseMoveNotifyWhenDone,
        ui_controls::LEFT, ui_controls::UP, draw_resonse_cb);

move_chain_cb = IgnoreResult<bool>(
    base::Bind(&ui_controls::SendMouseMoveNotifyWhenDone,
        ui_controls::LEFT, ui_controls::UP, move_chain_cb);

for (size_t i = drag_path.size() - 1; i > 0; --i) {
   ...
   move_chain_cb = IgnoreResult<bool>(
       base::Bind(&ui_controls::SendMouseMoveNotifyWhenDone,
           dest_x, dest_y, move_chain_cb);
   move_chain_cb = IgnoreResult<bool>(
       base::Bind(&ui_controls::SendMouseMoveNotifyWhenDone,
           half_step_x, half_step_y, move_chain_cb);
}


move_chain_cb = IgnoreResult<bool>(
    base::Bind(&ui_controls::SendMouseMoveNotifyWhenDone,
        ui_controls::LEFT, ui_controls::DOWN, move_chain_cb);

ui_controls::SendMouseMoveNotifyWhenDone(x + drag_path[0].x(),
    y + drag_path[0].y(),
    move_chain_cb);

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

Done.

     }
-    next_task = new MouseEventTask(next_task, ui_controls::DOWN);
+    base::Closure task6 =
+        base::Bind(&SendMouseEventsNotifyWhenDoneWithoutResult,
+                   ui_controls::LEFT, ui_controls::DOWN, *task);
 
     ui_controls::SendMouseMoveNotifyWhenDone(x + drag_path[0].x(),
                                              y + drag_path[0].y(),
-                                             next_task);
+                                             task6);
   } else {
     AutomationMsg_WindowDrag::WriteReplyParams(reply_message, false);
     Send(reply_message);
   }
 }