linux: More automation 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 955 matching lines @@
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowHWND, GetWindowHWND)
 #endif  // defined(OS_WIN)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowExecuteCommandAsync,
                         ExecuteBrowserCommandAsync)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WindowExecuteCommand,
                         ExecuteBrowserCommand)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowViewBounds, WindowGetViewBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowBounds, SetWindowBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowVisible, SetWindowVisible)
-#if defined(OS_WIN)
+#if defined(OS_WIN) || defined(OS_LINUX)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowClick, WindowSimulateClick)
-#endif  // defined(OS_WIN)
-#if defined(OS_WIN) || defined(OS_LINUX)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowKeyPress, WindowSimulateKeyPress)
 #endif
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WindowDrag,
                                     WindowSimulateDrag)
 #endif  // defined(OS_WIN)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabCount, GetTabCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_Tab, GetTab)
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabHWND, GetTabHWND)
@@ skipping 493 matching lines @@
   AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message, false);
   Send(reply_message);
 }
 
 void AutomationProvider::WindowGetViewBounds(int handle, int view_id,
                                              bool screen_coordinates,
                                              bool* success,
                                              gfx::Rect* bounds) {
   *success = false;
 
-#if defined(OS_WIN)
-  void* iter = NULL;
-  if (window_tracker_->ContainsHandle(handle)) {
-    HWND hwnd = window_tracker_->GetResource(handle);
-    views::RootView* root_view = views::WidgetWin::FindRootView(hwnd);
+  gfx::NativeWindow window = window_tracker_->GetResource(handle);
+  if (window) {
+#if defined(TOOLKIT_VIEWS)
+    views::RootView* root_view = views::WidgetWin::FindRootView(window);
     if (root_view) {
       views::View* view = root_view->GetViewByID(view_id);
       if (view) {
         *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);
       }
     }
+#else
+    NOTIMPLEMENTED();
+#endif
   }
-#else
-  // TODO(port): Enable when window_tracker is ported.
-  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 {
  public:
   MouseEventTask(views::View* view,
                  views::Event::EventType type,
@@ skipping 87 matching lines @@
     AutomationMsg_WindowDrag::WriteReplyParams(reply_message_, true);
     provider_->Send(reply_message_);
   }
 
  private:
   AutomationProvider* provider_;
   IPC::Message* reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowDragResponseTask);
 };
+#endif  // defined(OS_WIN)
 
+#if defined(OS_WIN) || defined(OS_LINUX)
 void AutomationProvider::WindowSimulateClick(const IPC::Message& message,
                                              int handle,
-                                             POINT click,
+                                             const gfx::Point& click,
                                              int flags) {
-  HWND hwnd = 0;
+  gfx::NativeWindow window = window_tracker_->GetResource(handle);
 
-  if (window_tracker_->ContainsHandle(handle)) {
-    hwnd = window_tracker_->GetResource(handle);
-
-    ui_controls::SendMouseMove(click.x, click.y);
+  if (window) {
+    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(button);
+    ui_controls::SendMouseClick(window, click, button);
   }
 }
+#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) {
   bool succeeded = false;
-  if (browser_tracker_->ContainsHandle(handle) && (drag_path.size() > 1)) {
+  gfx::NativeWindow window = window_tracker_->GetResource(handle);
+  if (window && (drag_path.size() > 1)) {
     succeeded = true;
 
     UINT down_message = 0;
     UINT up_message = 0;
     WPARAM wparam_flags = 0;
     if (flags & views::Event::EF_SHIFT_DOWN)
       wparam_flags |= MK_SHIFT;
     if (flags & views::Event::EF_CONTROL_DOWN)
       wparam_flags |= MK_CONTROL;
     if (flags & views::Event::EF_LEFT_BUTTON_DOWN) {
@@ skipping 27 matching lines @@
       MoveMouse(temp);
       SendMessage(top_level_hwnd, WM_MOUSEMOVE, wparam_flags,
                   MAKELPARAM(drag_path[i].x, drag_path[i].y));
     }
     POINT end = drag_path[drag_path.size() - 1];
     MapWindowPoints(top_level_hwnd, HWND_DESKTOP, &end, 1);
     MoveMouse(end);
 
     if (press_escape_en_route) {
       // Press Escape.
-      ui_controls::SendKeyPress(VK_ESCAPE,
+      ui_controls::SendKeyPress(window, VK_ESCAPE,
                                ((flags & views::Event::EF_CONTROL_DOWN)
                                 == views::Event::EF_CONTROL_DOWN),
                                ((flags & views::Event::EF_SHIFT_DOWN) ==
                                 views::Event::EF_SHIFT_DOWN),
                                ((flags & views::Event::EF_ALT_DOWN) ==
                                 views::Event::EF_ALT_DOWN));
     }
     SendMessage(top_level_hwnd, up_message, wparam_flags,
                 MAKELPARAM(end.x, end.y));
 
     MessageLoop::current()->PostTask(FROM_HERE, new InvokeTaskLaterTask(
         new WindowDragResponseTask(this, reply_message)));
   } else {
     AutomationMsg_WindowDrag::WriteReplyParams(reply_message, true);
     Send(reply_message);
   }
 }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_WIN) || defined(OS_LINUX)
 void AutomationProvider::WindowSimulateKeyPress(const IPC::Message& message,
                                                 int handle,
                                                 wchar_t key,
                                                 int flags) {
-  if (!window_tracker_->ContainsHandle(handle))
+  gfx::NativeWindow window = window_tracker_->GetResource(handle);
+  if (!window)
     return;
 
   // The key event is sent to whatever window is active.
-  ui_controls::SendKeyPress(key,
+  ui_controls::SendKeyPress(window, key,
                            ((flags & views::Event::EF_CONTROL_DOWN) ==
                               views::Event::EF_CONTROL_DOWN),
                             ((flags & views::Event::EF_SHIFT_DOWN) ==
                               views::Event::EF_SHIFT_DOWN),
                             ((flags & views::Event::EF_ALT_DOWN) ==
                               views::Event::EF_ALT_DOWN));
 }
 #endif
 
 #if defined(OS_WIN)
@@ skipping 1350 matching lines @@
       NOTREACHED();
       return NULL;
     }
 
     RenderViewHost* view_host = tab_contents->render_view_host();
     return view_host;
   }
 
   return NULL;
 }