Implement UI automation on the Mac....

chrome/browser/automation/automation_provider.cc

 // Copyright (c) 2010 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 <set>
 
 #include "app/l10n_util.h"
 #include "app/message_box_flags.h"
@@ skipping 62 matching lines @@
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/platform_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/automation/automation_messages.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "net/proxy/proxy_service.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/url_request/url_request_context.h"
+#include "chrome/browser/automation/ui_controls.h"
 #include "views/event.h"
 
 #if defined(OS_WIN)
 // TODO(port): Port these headers.
 #include "chrome/browser/character_encoding.h"
 #include "chrome/browser/download/save_package.h"
 #include "chrome/browser/external_tab_container.h"
 #include "chrome/browser/printing/print_job.h"
 #endif  // defined(OS_WIN)
 
-#if !defined(OS_MACOSX)
-// TODO(port): Port these to the mac.
-#include "chrome/browser/automation/ui_controls.h"
-#endif  // !defined(OS_MACOSX)
-
 using base::Time;
 
 class AutomationInterstitialPage : public InterstitialPage {
  public:
   AutomationInterstitialPage(TabContents* tab,
                              const GURL& url,
                              const std::string& contents)
       : InterstitialPage(tab, true, url),
         contents_(contents) {
   }
 
   virtual std::string GetHTMLContents() { return contents_; }
 
  private:
   std::string contents_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationInterstitialPage);
 };
 
-#if !defined(OS_MACOSX)
 class ClickTask : public Task {
  public:
   explicit ClickTask(int flags) : 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(button);
   }
 
  private:
   int flags_;
 
   DISALLOW_COPY_AND_ASSIGN(ClickTask);
 };
-#endif
 
 AutomationProvider::AutomationProvider(Profile* profile)
     : redirect_query_(0),
       profile_(profile),
       reply_message_(NULL),
       popup_menu_waiter_(NULL) {
   browser_tracker_.reset(new AutomationBrowserTracker(this));
   extension_tracker_.reset(new AutomationExtensionTracker(this));
   tab_tracker_.reset(new AutomationTabTracker(this));
   window_tracker_.reset(new AutomationWindowTracker(this));
@@ skipping 197 matching lines @@
     IPC_MESSAGE_HANDLER(AutomationMsg_IsWindowMaximized, IsWindowMaximized)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowExecuteCommandAsync,
                         ExecuteBrowserCommandAsync)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WindowExecuteCommand,
                         ExecuteBrowserCommand)
     IPC_MESSAGE_HANDLER(AutomationMsg_TerminateSession, TerminateSession)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowViewBounds, WindowGetViewBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetWindowBounds, GetWindowBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowBounds, SetWindowBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowVisible, SetWindowVisible)
-#if !defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowClick, WindowSimulateClick)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowMouseMove, WindowSimulateMouseMove)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowKeyPress, WindowSimulateKeyPress)
+#if !defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WindowDrag,
                                     WindowSimulateDrag)
-#endif
+#endif  // !defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabCount, GetTabCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_Type, GetType)
     IPC_MESSAGE_HANDLER(AutomationMsg_Tab, GetTab)
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabHWND, GetTabHWND)
 #endif  // defined(OS_WIN)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabProcessID, GetTabProcessID)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabTitle, GetTabTitle)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabIndex, GetTabIndex)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabURL, GetTabURL)
@@ skipping 590 matching lines @@
   virtual void Run() {
     MessageLoop::current()->PostTask(FROM_HERE, task_);
   }
 
  private:
   Task* task_;
 
   DISALLOW_COPY_AND_ASSIGN(InvokeTaskLaterTask);
 };
 
-#if !defined(OS_MACOSX)
 void AutomationProvider::WindowSimulateClick(const IPC::Message& message,
                                              int handle,
                                              const gfx::Point& click,
                                              int flags) {
   if (window_tracker_->ContainsHandle(handle)) {
     ui_controls::SendMouseMoveNotifyWhenDone(click.x(), click.y(),
                                              new ClickTask(flags));
   }
 }
 
@@ skipping 12 matching lines @@
     return;
 
   gfx::NativeWindow window = window_tracker_->GetResource(handle);
   // The key event is sent to whatever window is active.
   ui_controls::SendKeyPress(window, static_cast<base::KeyboardCode>(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));
+                              views::Event::EF_ALT_DOWN),
+                            ((flags & views::Event::EF_COMMAND_DOWN) ==
+                              views::Event::EF_COMMAND_DOWN));
 }
-#endif  // !defined(OS_MACOSX)
 
 void AutomationProvider::IsWindowActive(int handle, bool* success,
                                         bool* is_active) {
   if (window_tracker_->ContainsHandle(handle)) {
     *is_active =
         platform_util::IsWindowActive(window_tracker_->GetResource(handle));
     *success = true;
   } else {
     *success = false;
     *is_active = false;
@@ skipping 2091 matching lines @@
 }
 
 void AutomationProvider::WaitForPopupMenuToOpen(IPC::Message* reply_message) {
   NOTIMPLEMENTED();
 }
 #endif  // !defined(TOOLKIT_VIEWS)
 
 void AutomationProvider::ResetToDefaultTheme() {
   profile_->ClearTheme();
 }