Linux: more interactive tests porting....

chrome/browser/automation/automation_provider.cc

 // Copyright (c) 2006-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/automation_provider.h"
 
 #include "app/l10n_util.h"
 #include "app/message_box_flags.h"
 #include "base/file_version_info.h"
 #include "base/json_reader.h"
@@ skipping 53 matching lines @@
 #if defined(OS_WIN) || defined(OS_LINUX)
 // TODO(port): Port these to the mac.
 #include "chrome/browser/automation/ui_controls.h"
 #endif
 
 #if defined(OS_WIN)
 #include "chrome/browser/views/bookmark_bar_view.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_win.h"
 #include "views/window/window.h"
+#elif defined(OS_LINUX)
+#include "chrome/browser/gtk/view_id_util.h"
 #endif
 
 using base::Time;
 
 #if defined(OS_WIN)
 static void MoveMouse(const POINT& point) {
   SetCursorPos(point.x, point.y);
 
   // Now, make sure that GetMessagePos returns the values we just set by
   // simulating a mouse move.  The value returned by GetMessagePos is updated
@@ skipping 696 matching lines @@
   }
 
   virtual std::string GetHTMLContents() { return contents_; }
 
  private:
   std::string contents_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationInterstitialPage);
 };
 
+#if !defined(OS_MACOSX)
+class ClickTask : public Task {
+ public:
+  ClickTask(gfx::Point point, int flags) : point_(point), flags_(flags) {}
+  virtual ~ClickTask() {}
+
+  virtual void Run() {
+    ui_controls::MouseButton button = ui_controls::LEFT;
+    if ((flags_ & views::Event::EF_LEFT_BUTTON_DOWN) ==
+        views::Event::EF_LEFT_BUTTON_DOWN) {
+      button = ui_controls::LEFT;
+    } else if ((flags_ & views::Event::EF_RIGHT_BUTTON_DOWN) ==
+        views::Event::EF_RIGHT_BUTTON_DOWN) {
+      button = ui_controls::RIGHT;
+    } else if ((flags_ & views::Event::EF_MIDDLE_BUTTON_DOWN) ==
+        views::Event::EF_MIDDLE_BUTTON_DOWN) {
+      button = ui_controls::MIDDLE;
+    } else {
+      NOTREACHED();
+    }
+
+    ui_controls::SendMouseClick(point_, button);
+  }
+
+ private:
+  gfx::Point point_;
+  int flags_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClickTask);
+};
+#endif
+
 AutomationProvider::AutomationProvider(Profile* profile)
     : redirect_query_(0),
       profile_(profile),
       reply_message_(NULL) {
   browser_tracker_.reset(new AutomationBrowserTracker(this));
   tab_tracker_.reset(new AutomationTabTracker(this));
   window_tracker_.reset(new AutomationWindowTracker(this));
   autocomplete_edit_tracker_.reset(
       new AutomationAutocompleteEditTracker(this));
   new_tab_ui_load_observer_.reset(new NewTabUILoadObserver(this));
@@ skipping 674 matching lines @@
         *success = true;
         gfx::Point point;
         if (screen_coordinates)
           views::View::ConvertPointToScreen(view, &point);
         else
           views::View::ConvertPointToView(view, root_view, &point);
         *bounds = view->GetLocalBounds(false);
         bounds->set_origin(point);
       }
     }
+#elif defined(OS_LINUX)
+    gfx::NativeWindow window = window_tracker_->GetResource(handle);
+    GtkWidget* widget = ViewIDUtil::GetWidget(GTK_WIDGET(window),
+                                              static_cast<ViewID>(view_id));
+    if (!widget)
+      return;
+    *success = true;
+    *bounds = gfx::Rect(0, 0,
+                        widget->allocation.width, widget->allocation.height);
+    gint x, y;
+    if (screen_coordinates) {
+      gdk_window_get_origin(widget->window, &x, &y);
+      if (GTK_WIDGET_NO_WINDOW(widget)) {
+        x += widget->allocation.x;
+        y += widget->allocation.y;
+      }
+    } else {
+      gtk_widget_translate_coordinates(widget, GTK_WIDGET(window),
+                                       0, 0, &x, &y);
+    }
+    bounds->set_origin(gfx::Point(x, y));
 #else
     NOTIMPLEMENTED();
 #endif
   }
 }
 
 #if defined(OS_WIN)
 // This task enqueues a mouse event on the event loop, so that the view
 // that it's being sent to can do the requisite post-processing.
 class MouseEventTask : public Task {
@@ skipping 99 matching lines @@
 };
 #endif  // defined(OS_WIN)
 
 #if defined(OS_WIN) || defined(OS_LINUX)
 void AutomationProvider::WindowSimulateClick(const IPC::Message& message,
                                              int handle,
                                              const gfx::Point& click,
                                              int flags) {
 
   if (window_tracker_->ContainsHandle(handle)) {
-    gfx::NativeWindow window = window_tracker_->GetResource(handle);
-    ui_controls::SendMouseMove(click.x(), click.y());
-
-    ui_controls::MouseButton button = ui_controls::LEFT;
-    if ((flags & views::Event::EF_LEFT_BUTTON_DOWN) ==
-        views::Event::EF_LEFT_BUTTON_DOWN) {
-      button = ui_controls::LEFT;
-    } else if ((flags & views::Event::EF_RIGHT_BUTTON_DOWN) ==
-        views::Event::EF_RIGHT_BUTTON_DOWN) {
-      button = ui_controls::RIGHT;
-    } else if ((flags & views::Event::EF_MIDDLE_BUTTON_DOWN) ==
-        views::Event::EF_MIDDLE_BUTTON_DOWN) {
-      button = ui_controls::MIDDLE;
-    } else {
-      NOTREACHED();
-    }
-    ui_controls::SendMouseClick(window, click, button);
+    ui_controls::SendMouseMoveNotifyWhenDone(click.x(), click.y(),
+                                             new ClickTask(click, flags));
   }
 }
 #endif
 
 #if defined(OS_WIN)
 void AutomationProvider::WindowSimulateDrag(int handle,
                                             std::vector<POINT> drag_path,
                                             int flags,
                                             bool press_escape_en_route,
                                             IPC::Message* reply_message) {
@@ skipping 1464 matching lines @@
       NOTREACHED();
       return NULL;
     }
 
     RenderViewHost* view_host = tab_contents->render_view_host();
     return view_host;
   }
 
   return NULL;
 }