GTTF: Continue moving testing automation bits to TestingAutomationProvider

chrome/browser/automation/testing_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/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"
 #include "chrome/test/automation/automation_messages.h"
 #include "net/url_request/url_request_context.h"
 
 namespace {
 
 class GetCookiesTask : public Task {
  public:
@@ skipping 94 matching lines @@
   const std::string name_;
   const scoped_refptr<URLRequestContextGetter> context_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCookieTask);
 };
 
 }  // namespace
 
 
 TestingAutomationProvider::TestingAutomationProvider(Profile* profile)
-    : AutomationProvider(profile) {
+    : AutomationProvider(profile),
+      redirect_query_(0) {
   BrowserList::AddObserver(this);
   registrar_.Add(this, NotificationType::SESSION_END,
                  NotificationService::AllSources());
 }
 
 TestingAutomationProvider::~TestingAutomationProvider() {
   BrowserList::RemoveObserver(this);
 }
 
 void TestingAutomationProvider::OnMessageReceived(
     const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(TestingAutomationProvider, message)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseBrowser, CloseBrowser)
     IPC_MESSAGE_HANDLER(AutomationMsg_CloseBrowserRequestAsync,
                         CloseBrowserAsync)
     IPC_MESSAGE_HANDLER(AutomationMsg_ActivateTab, ActivateTab)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_AppendTab, AppendTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_ActiveTabIndex, GetActiveTabIndex)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseTab, CloseTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetCookies, GetCookies)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetCookie, SetCookie)
     IPC_MESSAGE_HANDLER(AutomationMsg_DeleteCookie, DeleteCookie)
     IPC_MESSAGE_HANDLER(AutomationMsg_ShowCollectedCookiesDialog,
                         ShowCollectedCookiesDialog)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_NavigateToURL, NavigateToURL)
     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()
 }
 
 void TestingAutomationProvider::OnChannelError() {
   BrowserList::CloseAllBrowsersAndExit();
   AutomationProvider::OnChannelError();
 }
 
@@ skipping 163 matching lines @@
       browser->OpenURL(url, GURL(), CURRENT_TAB, PageTransition::TYPED);
       return;
     }
   }
 
   AutomationMsg_NavigateToURL::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
   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) {
 }
 
 void TestingAutomationProvider::OnBrowserRemoving(const Browser* browser) {
   // For backwards compatibility with the testing automation interface, we
   // want the automation provider (and hence the process) to go away when the
   // last browser goes away.
   if (BrowserList::size() == 1 && !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kKeepAliveForTest)) {
     // If you change this, update Observer for NotificationType::SESSION_END
     // below.
     MessageLoop::current()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &TestingAutomationProvider::OnRemoveProvider));
   }
 }
 
 void TestingAutomationProvider::Observe(NotificationType type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
   DCHECK(type == NotificationType::SESSION_END);
   // OnBrowserRemoving does a ReleaseLater. When session end is received we exit
   // before the task runs resulting in this object not being deleted. This
   // Release balance out the Release scheduled by OnBrowserRemoving.
   Release();
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   AutomationProviderList::GetInstance()->RemoveProvider(this);
 }