GTTF: Continue moving testing automation bits to TestingAutomationProvider

TEST=ui_tests, chrome_frame_tests
BUG=52097

Review URL: http://codereview.chromium.org/3195011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@56910 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 267 insertions, 254 deletions

diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index e6ca4d1f..b48f0b7 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -160,8 +160,7 @@ class ClickTask : public Task {
 };
 
 AutomationProvider::AutomationProvider(Profile* profile)
-    : redirect_query_(0),
-      profile_(profile),
+    : profile_(profile),
       reply_message_(NULL),
       popup_menu_waiter_(NULL) {
   TRACE_EVENT_BEGIN("AutomationProvider::AutomationProvider", 0, "");
@@ -335,20 +334,6 @@ Extension* AutomationProvider::GetDisabledExtension(int extension_handle) {
 
 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,
@@ -573,185 +558,11 @@ void AutomationProvider::OnMessageReceived(const IPC::Message& message) {
   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 =
@@ -1014,29 +825,6 @@ void AutomationProvider::OnChannelError() {
   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);
diff --git a/chrome/browser/automation/automation_provider.h b/chrome/browser/automation/automation_provider.h
index 7a2c7b7..ef28206 100644
--- a/chrome/browser/automation/automation_provider.h
+++ b/chrome/browser/automation/automation_provider.h
@@ -53,10 +53,12 @@ class Extension;
 class ExtensionPortContainer;
 class ExtensionTestResultNotificationObserver;
 class ExternalTabContainer;
+class InitialLoadObserver;
 class LoginHandler;
 class MetricEventDurationObserver;
-class InitialLoadObserver;
+class NavigationController;
 class NavigationControllerRestoredObserver;
+class Profile;
 struct AutocompleteMatchData;
 
 namespace gfx {
@@ -166,11 +168,22 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
   scoped_ptr<AutomationBrowserTracker> browser_tracker_;
   scoped_ptr<AutomationTabTracker> tab_tracker_;
 
+  typedef std::map<NavigationController*, LoginHandler*> LoginHandlerMap;
+  LoginHandlerMap login_handler_map_;
+
+  Profile* profile_;
+
+  // A pointer to reply message used when we do asynchronous processing in the
+  // message handler.
+  // TODO(phajdan.jr): Remove |reply_message_|, it is error-prone.
+  IPC::Message* reply_message_;
+
+  // Consumer for asynchronous history queries.
+  CancelableRequestConsumer consumer_;
+
  private:
   // IPC Message callbacks.
-  void GetBrowserWindowCount(int* window_count);
   void GetBrowserLocale(string16* locale);
-  void GetNormalBrowserWindowCount(int* window_count);
   void GetShowingAppModalDialog(bool* showing_dialog, int* dialog_button);
   void ClickAppModalDialogButton(int button, bool* success);
   void ShutdownSessionService(int handle, bool* result);
@@ -221,21 +234,6 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
   void GetTabIndex(int handle, int* tabstrip_index);
   void GetTabURL(int handle, bool* success, GURL* url);
   void HandleUnused(const IPC::Message& message, int handle);
-  void NavigationAsync(int handle, const GURL& url, bool* status);
-  void NavigationAsyncWithDisposition(int handle,
-                                      const GURL& url,
-                                      WindowOpenDisposition disposition,
-                                      bool* status);
-  void GoBack(int handle, IPC::Message* reply_message);
-  void GoForward(int handle, IPC::Message* reply_message);
-  void Reload(int handle, IPC::Message* reply_message);
-  void SetAuth(int tab_handle, const std::wstring& username,
-               const std::wstring& password, IPC::Message* reply_message);
-  void CancelAuth(int tab_handle, IPC::Message* reply_message);
-  void NeedsAuth(int tab_handle, bool* needs_auth);
-  void GetRedirectsFrom(int tab_handle,
-                        const GURL& source_url,
-                        IPC::Message* reply_message);
   void ExecuteJavascript(int handle,
                          const std::wstring& frame_xpath,
                          const std::wstring& script,
@@ -820,13 +818,6 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
                             IPC::Message* reply_message);
 #endif
 
-  // Callback for history redirect queries.
-  virtual void OnRedirectQueryComplete(
-      HistoryService::Handle request_handle,
-      GURL from_url,
-      bool success,
-      history::RedirectList* redirects);
-
   // Returns the associated view for the tab handle passed in.
   // Returns NULL on failure.
   RenderViewHost* GetViewForTab(int tab_handle);
@@ -917,7 +908,6 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
 #endif  // defined(OS_WIN)
 
   typedef ObserverList<NotificationObserver> NotificationObserverList;
-  typedef std::map<NavigationController*, LoginHandler*> LoginHandlerMap;
   typedef std::map<int, ExtensionPortContainer*> PortContainerMap;
 
   scoped_ptr<IPC::ChannelProxy> channel_;
@@ -933,25 +923,11 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
   scoped_ptr<AutomationWindowTracker> window_tracker_;
   scoped_ptr<AutomationAutocompleteEditTracker> autocomplete_edit_tracker_;
   scoped_ptr<NavigationControllerRestoredObserver> restore_tracker_;
-  LoginHandlerMap login_handler_map_;
   PortContainerMap port_containers_;
   NotificationObserverList notification_observer_list_;
   scoped_refptr<AutomationResourceMessageFilter>
       automation_resource_message_filter_;
 
-  // Handle for an in-process redirect query. We expect only one redirect query
-  // at a time (we should have only one caller, and it will block while waiting
-  // for the results) so there is only one handle. When non-0, indicates a
-  // query in progress.
-  HistoryService::Handle redirect_query_;
-
-  // Consumer for asynchronous history queries.
-  CancelableRequestConsumer consumer_;
-
-  Profile* profile_;
-
-  IPC::Message* reply_message_;
-
   // Keep track of whether a popup menu has been opened since the last time
   // that StartTrackingPopupMenus has been called.
   bool popup_menu_opened_;
diff --git a/chrome/browser/automation/testing_automation_provider.cc b/chrome/browser/automation/testing_automation_provider.cc
index 2a21cda..f62079b 100644
--- a/chrome/browser/automation/testing_automation_provider.cc
+++ b/chrome/browser/automation/testing_automation_provider.cc
@@ -5,11 +5,13 @@
 #include "chrome/browser/automation/testing_automation_provider.h"
 
 #include "base/command_line.h"
+#include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/automation/automation_browser_tracker.h"
 #include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/automation/automation_provider_observers.h"
 #include "chrome/browser/automation/automation_tab_tracker.h"
 #include "chrome/browser/browser_window.h"
+#include "chrome/browser/login_prompt.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "chrome/common/notification_service.h"
@@ -124,7 +126,8 @@ class DeleteCookieTask : public Task {
 
 
 TestingAutomationProvider::TestingAutomationProvider(Profile* profile)
-    : AutomationProvider(profile) {
+    : AutomationProvider(profile),
+      redirect_query_(0) {
   BrowserList::AddObserver(this);
   registrar_.Add(this, NotificationType::SESSION_END,
                  NotificationService::AllSources());
@@ -153,6 +156,20 @@ void TestingAutomationProvider::OnMessageReceived(
     IPC_MESSAGE_HANDLER_DELAY_REPLY(
         AutomationMsg_NavigateToURLBlockUntilNavigationsComplete,
         NavigateToURLBlockUntilNavigationsComplete)
+    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_UNHANDLED(AutomationProvider::OnMessageReceived(message));
   IPC_END_MESSAGE_MAP()
@@ -336,6 +353,207 @@ void TestingAutomationProvider::NavigateToURLBlockUntilNavigationsComplete(
   Send(reply_message);
 }
 
+void TestingAutomationProvider::NavigationAsync(int handle,
+                                                const GURL& url,
+                                                bool* status) {
+  NavigationAsyncWithDisposition(handle, url, CURRENT_TAB, status);
+}
+
+void TestingAutomationProvider::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 TestingAutomationProvider::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 TestingAutomationProvider::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 TestingAutomationProvider::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 TestingAutomationProvider::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 TestingAutomationProvider::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 TestingAutomationProvider::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 TestingAutomationProvider::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,
+                      &TestingAutomationProvider::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 TestingAutomationProvider::GetBrowserWindowCount(int* window_count) {
+  *window_count = static_cast<int>(BrowserList::size());
+}
+
+void TestingAutomationProvider::GetNormalBrowserWindowCount(int* window_count) {
+  *window_count = static_cast<int>(
+      BrowserList::GetBrowserCountForType(profile_, Browser::TYPE_NORMAL));
+}
+
+// TODO(brettw) change this to accept GURLs when history supports it
+void TestingAutomationProvider::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;
+}
+
 void TestingAutomationProvider::OnBrowserAdded(const Browser* browser) {
 }
 
diff --git a/chrome/browser/automation/testing_automation_provider.h b/chrome/browser/automation/testing_automation_provider.h
index 1da6e80..55588e9 100644
--- a/chrome/browser/automation/testing_automation_provider.h
+++ b/chrome/browser/automation/testing_automation_provider.h
@@ -9,6 +9,7 @@
 #include "base/basictypes.h"
 #include "chrome/browser/automation/automation_provider.h"
 #include "chrome/browser/browser_list.h"
+#include "chrome/browser/history/history.h"
 #include "chrome/common/notification_registrar.h"
 
 // This is an automation provider containing testing calls.
@@ -52,6 +53,30 @@ class TestingAutomationProvider : public AutomationProvider,
   void NavigateToURLBlockUntilNavigationsComplete(int handle, const GURL& url,
                                                   int number_of_navigations,
                                                   IPC::Message* reply_message);
+  void NavigationAsync(int handle, const GURL& url, bool* status);
+  void NavigationAsyncWithDisposition(int handle,
+                                      const GURL& url,
+                                      WindowOpenDisposition disposition,
+                                      bool* status);
+  void GoBack(int handle, IPC::Message* reply_message);
+  void GoForward(int handle, IPC::Message* reply_message);
+  void Reload(int handle, IPC::Message* reply_message);
+  void SetAuth(int tab_handle, const std::wstring& username,
+               const std::wstring& password, IPC::Message* reply_message);
+  void CancelAuth(int tab_handle, IPC::Message* reply_message);
+  void NeedsAuth(int tab_handle, bool* needs_auth);
+  void GetRedirectsFrom(int tab_handle,
+                        const GURL& source_url,
+                        IPC::Message* reply_message);
+  void GetBrowserWindowCount(int* window_count);
+  void GetNormalBrowserWindowCount(int* window_count);
+
+  // Callback for history redirect queries.
+  virtual void OnRedirectQueryComplete(
+      HistoryService::Handle request_handle,
+      GURL from_url,
+      bool success,
+      history::RedirectList* redirects);
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
@@ -59,6 +84,12 @@ class TestingAutomationProvider : public AutomationProvider,
 
   void OnRemoveProvider();  // Called via PostTask
 
+  // Handle for an in-process redirect query. We expect only one redirect query
+  // at a time (we should have only one caller, and it will block while waiting
+  // for the results) so there is only one handle. When non-0, indicates a
+  // query in progress.
+  HistoryService::Handle redirect_query_;
+
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(TestingAutomationProvider);