Couple of tweaks to ui_controls_linux:...

chrome/browser/automation/ui_controls_linux.cc

 // Copyright (c) 2009 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 <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
 
 #include "base/gfx/rect.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/test/automation/automation_constants.h"
 
+#if defined(TOOLKIT_VIEWS)
+#include "views/view.h"
+#include "views/widget/widget.h"
+#endif
+
 namespace {
 
 guint32 EventTimeNow() {
   struct timespec ts;
   clock_gettime(CLOCK_MONOTONIC, &ts);
   return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
 }
 
 class EventWaiter : public MessageLoopForUI::Observer {
  public:
   EventWaiter(Task* task, GdkEventType type) : task_(task), type_(type) {
     MessageLoopForUI::current()->AddObserver(this);
   }
 
   virtual ~EventWaiter() {
     MessageLoopForUI::current()->RemoveObserver(this);
   }
 
   // MessageLoop::Observer implementation:
   virtual void WillProcessEvent(GdkEvent* event) {
-    // No-op.
-  }
-
-  virtual void DidProcessEvent(GdkEvent* event) {
-    if (event->any.type == type_) {
-      task_->Run();
+    if (event->type == type_) {
+      // 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.
+      // NOTE: if processing a message results in running a nested message
+      // loop, then DidProcessEvent isn't immediately sent. As such, we do
+      // the processing in WillProcessEvent rather than DidProcessEvent.
+      MessageLoop::current()->PostTask(FROM_HERE, task_);
       delete this;
     }
   }
 
+  virtual void DidProcessEvent(GdkEvent* event) {
+    // No-op.
+  }
+
  private:
-  scoped_ptr<Task> task_;
+  // We pass ownership of task_ to MessageLoop when the corrent event is
+  // received.
+  Task *task_;
   GdkEventType type_;
 };
 
 class ClickTask : public Task {
  public:
   ClickTask(ui_controls::MouseButton button, int state, Task* followup)
       : button_(button), state_(state), followup_(followup)  {
   }
 
   virtual ~ClickTask() {}
 
   virtual void Run() {
-    ui_controls::SendMouseEventsNotifyWhenDone(button_, state_, followup_);
+    if (followup_)
+      ui_controls::SendMouseEventsNotifyWhenDone(button_, state_, followup_);
+    else
+      ui_controls::SendMouseEvents(button_, state_);
   }
 
  private:
   ui_controls::MouseButton button_;
   int state_;
   Task* followup_;
 };
 
 }  // namespace
 
 namespace ui_controls {
 
 bool SendKeyPress(gfx::NativeWindow window,
                   wchar_t key, bool control, bool shift, bool alt) {
   // TODO(estade): send a release as well?
   GdkEvent* event = gdk_event_new(GDK_KEY_PRESS);
 
   event->key.type = GDK_KEY_PRESS;
-  event->key.window = GTK_WIDGET(window)->window;
+  GtkWidget* grab_widget = gtk_grab_get_current();
+  if (grab_widget) {
+    // If there is a grab, send all events to the grabbed widget.
+    event->key.window = grab_widget->window;
+  } else if (window) {
+    event->key.window = GTK_WIDGET(window)->window;
+  } else {
+    // No target was specified. Send the events to the focused window.
+    GList* windows = gtk_window_list_toplevels();
+    for (GList* element = windows; element; element = g_list_next(element)) {
+      GtkWindow* window = GTK_WINDOW(element->data);
+      if (gtk_window_is_active(window)) {
+        event->key.window = GTK_WIDGET(window)->window;
+        break;
+      }
+    }
+    g_list_free(windows);
+  }
+  DCHECK(event->key.window);
   g_object_ref(event->key.window);
   event->key.send_event = false;
   event->key.time = EventTimeNow();
 
   // TODO(estade): handle other state flags besides control, shift, alt?
   // For example caps lock.
   event->key.state = (control ? GDK_CONTROL_MASK : 0) |
                      (shift ? GDK_SHIFT_MASK : 0) |
                      (alt ? GDK_MOD1_MASK : 0);
   event->key.keyval = key;
@@ skipping 39 matching lines @@
   return rv;
 }
 
 bool SendMouseEvents(MouseButton type, int state) {
   GdkEvent* event = gdk_event_new(GDK_BUTTON_PRESS);
 
   event->button.send_event = false;
   event->button.time = EventTimeNow();
 
   gint x, y;
-  event->button.window = gdk_window_at_pointer(&x, &y);
+  GtkWidget* grab_widget = gtk_grab_get_current();
+  if (grab_widget) {
+    // If there is a grab, we need to target all events at it regardless of
+    // what widget the mouse is over.
+    event->button.window = grab_widget->window;
+    gdk_window_get_pointer(event->button.window, &x, &y, NULL);
+  } else {
+    event->button.window = gdk_window_at_pointer(&x, &y);
+  }
   g_object_ref(event->button.window);
   event->motion.x = x;
   event->motion.y = y;
   gint origin_x, origin_y;
   gdk_window_get_origin(event->button.window, &origin_x, &origin_y);
   event->button.x_root = x + origin_x;
   event->button.y_root = y + origin_y;
 
   event->button.axes = NULL;
   // TODO(estade): as above, we may want to pack this with the actual state.
@@ skipping 13 matching lines @@
     gdk_event_put(release_event);
 
   gdk_event_free(event);
   gdk_event_free(release_event);
 
   return false;
 }
 
 bool SendMouseEventsNotifyWhenDone(MouseButton type, int state, Task* task) {
   bool rv = SendMouseEvents(type, state);
-  MessageLoop::current()->PostTask(FROM_HERE, task);
+  GdkEventType wait_type;
+  if (state & UP) {
+    wait_type = GDK_BUTTON_RELEASE;
+  } else {
+    if (type == LEFT)
+      wait_type = GDK_BUTTON_PRESS;
+    else if (type == MIDDLE)
+      wait_type = GDK_2BUTTON_PRESS;
+    else
+      wait_type = GDK_3BUTTON_PRESS;
+  }
+  new EventWaiter(task, wait_type);
   return rv;
 }
 
 bool SendMouseClick(MouseButton type) {
   return SendMouseEvents(type, UP | DOWN);
 }
 
+#if defined(TOOLKIT_VIEWS)
+void MoveMouseToCenterAndPress(views::View* view, MouseButton button,
+                               int state, Task* task) {
+  gfx::Point view_center(view->width() / 2, view->height() / 2);
+  views::View::ConvertPointToScreen(view, &view_center);
+  SendMouseMoveNotifyWhenDone(view_center.x(), view_center.y(),
+                              new ClickTask(button, state, task));
+}
+#else
 void MoveMouseToCenterAndPress(GtkWidget* widget,
                                MouseButton button,
                                int state,
                                Task* task) {
   gfx::Rect bounds = gtk_util::GetWidgetScreenBounds(widget);
   SendMouseMoveNotifyWhenDone(bounds.x() + bounds.width() / 2,
                               bounds.y() + bounds.height() / 2,
                               new ClickTask(button, state, task));
 }
+#endif
 
 }  // namespace ui_controls