GTTF: next batch of automation separation.

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/message_box_flags.h"
 #include "base/callback.h"
@@ skipping 316 matching lines @@
   ExtensionsService* service = profile_->GetExtensionsService();
   if (extension && service &&
       service->GetExtensionById(extension->id(), true) &&
       !service->GetExtensionById(extension->id(), false))
     return extension;
   return NULL;
 }
 
 void AutomationProvider::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(AutomationProvider, message)
-    IPC_MESSAGE_HANDLER(AutomationMsg_BrowserWindow, GetBrowserWindow)
-    IPC_MESSAGE_HANDLER(AutomationMsg_GetBrowserLocale, GetBrowserLocale)
-    IPC_MESSAGE_HANDLER(AutomationMsg_LastActiveBrowserWindow,
-                        GetLastActiveBrowserWindow)
-    IPC_MESSAGE_HANDLER(AutomationMsg_ActiveWindow, GetActiveWindow)
-    IPC_MESSAGE_HANDLER(AutomationMsg_FindNormalBrowserWindow,
-                        FindNormalBrowserWindow)
-    IPC_MESSAGE_HANDLER(AutomationMsg_IsWindowActive, IsWindowActive)
-    IPC_MESSAGE_HANDLER(AutomationMsg_ActivateWindow, ActivateWindow)
-    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)
     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,
@@ skipping 190 matching lines @@
     IPC_MESSAGE_HANDLER(AutomationMsg_RunUnloadHandlers, OnRunUnloadHandlers)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetZoomLevel, OnSetZoomLevel)
 #endif  // defined(OS_WIN)
 #if defined(OS_CHROMEOS)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_LoginWithUserAndPass,
                                     LoginWithUserAndPass)
 #endif  // defined(OS_CHROMEOS)
   IPC_END_MESSAGE_MAP()
 }
 
-void AutomationProvider::GetBrowserLocale(string16* locale) {
-  DCHECK(g_browser_process);
-  *locale = ASCIIToUTF16(g_browser_process->GetApplicationLocale());
-}
-
 void AutomationProvider::GetShowingAppModalDialog(bool* showing_dialog,
                                                   int* dialog_button) {
   AppModalDialog* dialog_delegate =
       Singleton<AppModalDialogQueue>()->active_dialog();
   *showing_dialog = (dialog_delegate != NULL);
   if (*showing_dialog)
     *dialog_button = dialog_delegate->GetDialogButtons();
   else
     *dialog_button = MessageBoxFlags::DIALOGBUTTON_NONE;
 }
@@ skipping 22 matching lines @@
 void AutomationProvider::ShutdownSessionService(int handle, bool* result) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     browser->profile()->ShutdownSessionService();
     *result = true;
   } else {
     *result = false;
   }
 }
 
-void AutomationProvider::GetBrowserWindow(int index, int* handle) {
-  *handle = 0;
-  if (index >= 0) {
-    BrowserList::const_iterator iter = BrowserList::begin();
-    for (; (iter != BrowserList::end()) && (index > 0); ++iter, --index) {}
-    if (iter != BrowserList::end()) {
-      *handle = browser_tracker_->Add(*iter);
-    }
-  }
-}
-
-void AutomationProvider::FindNormalBrowserWindow(int* handle) {
-  *handle = 0;
-  Browser* browser = BrowserList::FindBrowserWithType(profile_,
-                                                      Browser::TYPE_NORMAL,
-                                                      false);
-  if (browser)
-    *handle = browser_tracker_->Add(browser);
-}
-
-void AutomationProvider::GetLastActiveBrowserWindow(int* handle) {
-  *handle = 0;
-  Browser* browser = BrowserList::GetLastActive();
-  if (browser)
-    *handle = browser_tracker_->Add(browser);
-}
-
-#if defined(OS_POSIX)
-// TODO(estade): use this implementation for all platforms?
-void AutomationProvider::GetActiveWindow(int* handle) {
-  gfx::NativeWindow window =
-      BrowserList::GetLastActive()->window()->GetNativeHandle();
-  *handle = window_tracker_->Add(window);
-}
-#endif
-
-void AutomationProvider::ExecuteBrowserCommandAsync(int handle, int command,
-                                                    bool* success) {
-  *success = false;
-  if (browser_tracker_->ContainsHandle(handle)) {
-    Browser* browser = browser_tracker_->GetResource(handle);
-    if (browser->command_updater()->SupportsCommand(command) &&
-        browser->command_updater()->IsCommandEnabled(command)) {
-      browser->ExecuteCommand(command);
-      *success = true;
-    }
-  }
-}
-
-void AutomationProvider::ExecuteBrowserCommand(
-    int handle, int command, IPC::Message* reply_message) {
-  // List of commands which just finish synchronously and don't require
-  // setting up an observer.
-  static const int kSynchronousCommands[] = {
-    IDC_HOME,
-    IDC_SELECT_NEXT_TAB,
-    IDC_SELECT_PREVIOUS_TAB,
-    IDC_SHOW_BOOKMARK_MANAGER,
-  };
-  if (browser_tracker_->ContainsHandle(handle)) {
-    Browser* browser = browser_tracker_->GetResource(handle);
-    if (browser->command_updater()->SupportsCommand(command) &&
-        browser->command_updater()->IsCommandEnabled(command)) {
-      // First check if we can handle the command without using an observer.
-      for (size_t i = 0; i < arraysize(kSynchronousCommands); i++) {
-        if (command == kSynchronousCommands[i]) {
-          browser->ExecuteCommand(command);
-          AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message,
-                                                               true);
-          Send(reply_message);
-          return;
-        }
-      }
-
-      // Use an observer if we have one, otherwise fail.
-      if (ExecuteBrowserCommandObserver::CreateAndRegisterObserver(
-          this, browser, command, reply_message)) {
-        browser->ExecuteCommand(command);
-        return;
-      }
-    }
-  }
-  AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message, false);
-  Send(reply_message);
-}
-
 // This task just adds another task to the event queue.  This is useful if
 // you want to ensure that any tasks added to the event queue after this one
 // have already been processed by the time |task| is run.
 class InvokeTaskLaterTask : public Task {
  public:
   explicit InvokeTaskLaterTask(Task* task) : task_(task) {}
   virtual ~InvokeTaskLaterTask() {}
 
   virtual void Run() {
     MessageLoop::current()->PostTask(FROM_HERE, task_);
@@ skipping 35 matching lines @@
                            ((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),
                             ((flags & views::Event::EF_COMMAND_DOWN) ==
                               views::Event::EF_COMMAND_DOWN));
 }
 
-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;
-  }
-}
-
 void AutomationProvider::GetTabCount(int handle, int* tab_count) {
   *tab_count = -1;  // -1 is the error code
 
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     *tab_count = browser->tab_count();
   }
 }
 
 void AutomationProvider::GetType(int handle, int* type_as_int) {
@@ skipping 3359 matching lines @@
 }
 
 void AutomationProvider::WaitForPopupMenuToOpen(IPC::Message* reply_message) {
   NOTIMPLEMENTED();
 }
 #endif  // !defined(TOOLKIT_VIEWS)
 
 void AutomationProvider::ResetToDefaultTheme() {
   profile_->ClearTheme();
 }