GTTF: Continue moving testing automation bits to TestingAutomationProvider

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 142 matching lines @@
     ui_controls::SendMouseClick(button);
   }
 
  private:
   int flags_;
 
   DISALLOW_COPY_AND_ASSIGN(ClickTask);
 };
 
 AutomationProvider::AutomationProvider(Profile* profile)
-    : redirect_query_(0),
-      profile_(profile),
+    : profile_(profile),
       reply_message_(NULL),
       popup_menu_waiter_(NULL) {
   TRACE_EVENT_BEGIN("AutomationProvider::AutomationProvider", 0, "");
 
   browser_tracker_.reset(new AutomationBrowserTracker(this));
   extension_tracker_.reset(new AutomationExtensionTracker(this));
   tab_tracker_.reset(new AutomationTabTracker(this));
   window_tracker_.reset(new AutomationWindowTracker(this));
   autocomplete_edit_tracker_.reset(
       new AutomationAutocompleteEditTracker(this));
@@ skipping 153 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_NavigationAsync, NavigationAsync)
-    IPC_MESSAGE_HANDLER(AutomationMsg_NavigationAsyncWithDisposition,
-                        NavigationAsyncWithDisposition)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_GoBack, GoBack)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_GoForward, GoForward)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_Reload, Reload)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_SetAuth, SetAuth)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CancelAuth, CancelAuth)
-    IPC_MESSAGE_HANDLER(AutomationMsg_NeedsAuth, NeedsAuth)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_RedirectsFrom,
-                                    GetRedirectsFrom)
-    IPC_MESSAGE_HANDLER(AutomationMsg_BrowserWindowCount, GetBrowserWindowCount)
-    IPC_MESSAGE_HANDLER(AutomationMsg_NormalBrowserWindowCount,
-                        GetNormalBrowserWindowCount)
     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)
@@ skipping 204 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::NavigationAsync(int handle,
-                                        const GURL& url,
-                                        bool* status) {
-  NavigationAsyncWithDisposition(handle, url, CURRENT_TAB, status);
-}
-
-void AutomationProvider::NavigationAsyncWithDisposition(
-    int handle,
-    const GURL& url,
-    WindowOpenDisposition disposition,
-    bool* status) {
-  *status = false;
-
-  if (tab_tracker_->ContainsHandle(handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(handle);
-
-    // Simulate what a user would do. Activate the tab and then navigate.
-    // We could allow navigating in a background tab in future.
-    Browser* browser = FindAndActivateTab(tab);
-
-    if (browser) {
-      // Don't add any listener unless a callback mechanism is desired.
-      // TODO(vibhor): Do this if such a requirement arises in future.
-      browser->OpenURL(url, GURL(), disposition, PageTransition::TYPED);
-      *status = true;
-    }
-  }
-}
-
-void AutomationProvider::GoBack(int handle, IPC::Message* reply_message) {
-  if (tab_tracker_->ContainsHandle(handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(handle);
-    Browser* browser = FindAndActivateTab(tab);
-    if (browser && browser->command_updater()->IsCommandEnabled(IDC_BACK)) {
-      AddNavigationStatusListener(tab, reply_message, 1, false);
-      browser->GoBack(CURRENT_TAB);
-      return;
-    }
-  }
-
-  AutomationMsg_GoBack::WriteReplyParams(
-      reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
-  Send(reply_message);
-}
-
-void AutomationProvider::GoForward(int handle, IPC::Message* reply_message) {
-  if (tab_tracker_->ContainsHandle(handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(handle);
-    Browser* browser = FindAndActivateTab(tab);
-    if (browser && browser->command_updater()->IsCommandEnabled(IDC_FORWARD)) {
-      AddNavigationStatusListener(tab, reply_message, 1, false);
-      browser->GoForward(CURRENT_TAB);
-      return;
-    }
-  }
-
-  AutomationMsg_GoForward::WriteReplyParams(
-      reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
-  Send(reply_message);
-}
-
-void AutomationProvider::Reload(int handle, IPC::Message* reply_message) {
-  if (tab_tracker_->ContainsHandle(handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(handle);
-    Browser* browser = FindAndActivateTab(tab);
-    if (browser && browser->command_updater()->IsCommandEnabled(IDC_RELOAD)) {
-      AddNavigationStatusListener(tab, reply_message, 1, false);
-      browser->Reload(CURRENT_TAB);
-      return;
-    }
-  }
-
-  AutomationMsg_Reload::WriteReplyParams(
-      reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
-  Send(reply_message);
-}
-
-void AutomationProvider::SetAuth(int tab_handle,
-                                 const std::wstring& username,
-                                 const std::wstring& password,
-                                 IPC::Message* reply_message) {
-  if (tab_tracker_->ContainsHandle(tab_handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
-    LoginHandlerMap::iterator iter = login_handler_map_.find(tab);
-
-    if (iter != login_handler_map_.end()) {
-      // If auth is needed again after this, assume login has failed.  This is
-      // not strictly correct, because a navigation can require both proxy and
-      // server auth, but it should be OK for now.
-      LoginHandler* handler = iter->second;
-      AddNavigationStatusListener(tab, reply_message, 1, false);
-      handler->SetAuth(username, password);
-      return;
-    }
-  }
-
-  AutomationMsg_SetAuth::WriteReplyParams(
-      reply_message, AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED);
-  Send(reply_message);
-}
-
-void AutomationProvider::CancelAuth(int tab_handle,
-                                    IPC::Message* reply_message) {
-  if (tab_tracker_->ContainsHandle(tab_handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
-    LoginHandlerMap::iterator iter = login_handler_map_.find(tab);
-
-    if (iter != login_handler_map_.end()) {
-      // If auth is needed again after this, something is screwy.
-      LoginHandler* handler = iter->second;
-      AddNavigationStatusListener(tab, reply_message, 1, false);
-      handler->CancelAuth();
-      return;
-    }
-  }
-
-  AutomationMsg_CancelAuth::WriteReplyParams(
-      reply_message, AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED);
-  Send(reply_message);
-}
-
-void AutomationProvider::NeedsAuth(int tab_handle, bool* needs_auth) {
-  *needs_auth = false;
-
-  if (tab_tracker_->ContainsHandle(tab_handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
-    LoginHandlerMap::iterator iter = login_handler_map_.find(tab);
-
-    if (iter != login_handler_map_.end()) {
-      // The LoginHandler will be in our map IFF the tab needs auth.
-      *needs_auth = true;
-    }
-  }
-}
-
-void AutomationProvider::GetRedirectsFrom(int tab_handle,
-                                          const GURL& source_url,
-                                          IPC::Message* reply_message) {
-  DCHECK(!redirect_query_) << "Can only handle one redirect query at once.";
-  if (tab_tracker_->ContainsHandle(tab_handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
-    HistoryService* history_service =
-        tab->profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
-
-    DCHECK(history_service) << "Tab " << tab_handle << "'s profile " <<
-                               "has no history service";
-    if (history_service) {
-      DCHECK(reply_message_ == NULL);
-      reply_message_ = reply_message;
-      // Schedule a history query for redirects. The response will be sent
-      // asynchronously from the callback the history system uses to notify us
-      // that it's done: OnRedirectQueryComplete.
-      redirect_query_ = history_service->QueryRedirectsFrom(
-          source_url, &consumer_,
-          NewCallback(this, &AutomationProvider::OnRedirectQueryComplete));
-      return;  // Response will be sent when query completes.
-    }
-  }
-
-  // Send failure response.
-  std::vector<GURL> empty;
-  AutomationMsg_RedirectsFrom::WriteReplyParams(reply_message, false, empty);
-  Send(reply_message);
-}
-
 void AutomationProvider::GetBrowserLocale(string16* locale) {
   DCHECK(g_browser_process);
   *locale = ASCIIToUTF16(g_browser_process->GetApplicationLocale());
 }
 
-void AutomationProvider::GetBrowserWindowCount(int* window_count) {
-  *window_count = static_cast<int>(BrowserList::size());
-}
-
-void AutomationProvider::GetNormalBrowserWindowCount(int* window_count) {
-  *window_count = static_cast<int>(
-      BrowserList::GetBrowserCountForType(profile_, Browser::TYPE_NORMAL));
-}
-
 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 242 matching lines @@
   if (window_tracker_->ContainsHandle(handle)) {
     window_tracker_->Remove(window_tracker_->GetResource(handle));
   }
 }
 
 void AutomationProvider::OnChannelError() {
   LOG(INFO) << "AutomationProxy went away, shutting down app.";
   AutomationProviderList::GetInstance()->RemoveProvider(this);
 }
 
-// TODO(brettw) change this to accept GURLs when history supports it
-void AutomationProvider::OnRedirectQueryComplete(
-    HistoryService::Handle request_handle,
-    GURL from_url,
-    bool success,
-    history::RedirectList* redirects) {
-  DCHECK(request_handle == redirect_query_);
-  DCHECK(reply_message_ != NULL);
-
-  std::vector<GURL> redirects_gurl;
-  reply_message_->WriteBool(success);
-  if (success) {
-    for (size_t i = 0; i < redirects->size(); i++)
-      redirects_gurl.push_back(redirects->at(i));
-  }
-
-  IPC::ParamTraits<std::vector<GURL> >::Write(reply_message_, redirects_gurl);
-
-  Send(reply_message_);
-  redirect_query_ = 0;
-  reply_message_ = NULL;
-}
-
 bool AutomationProvider::Send(IPC::Message* msg) {
   DCHECK(channel_.get());
   return channel_->Send(msg);
 }
 
 Browser* AutomationProvider::FindAndActivateTab(
     NavigationController* controller) {
   int tab_index;
   Browser* browser = Browser::GetBrowserForController(controller, &tab_index);
   if (browser)
@@ skipping 3288 matching lines @@
 }
 
 void AutomationProvider::WaitForPopupMenuToOpen(IPC::Message* reply_message) {
   NOTIMPLEMENTED();
 }
 #endif  // !defined(TOOLKIT_VIEWS)
 
 void AutomationProvider::ResetToDefaultTheme() {
   profile_->ClearTheme();
 }