Add automation call to wait for multiple navigations.

chrome/browser/automation/automation_provider.cc

 // Copyright (c) 2006-2009 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 "app/l10n_util.h"
 #include "app/message_box_flags.h"
 #include "base/file_version_info.h"
 #include "base/json_reader.h"
@@ skipping 208 matching lines @@
   NavigationController* controller_;
   IPC::Message* reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationControllerRestoredObserver);
 };
 
 class NavigationNotificationObserver : public NotificationObserver {
  public:
   NavigationNotificationObserver(NavigationController* controller,
                                  AutomationProvider* automation,
-                                 IPC::Message* reply_message)
+                                 IPC::Message* reply_message,
+                                 int number_of_navigations)
     : automation_(automation),
       reply_message_(reply_message),
       controller_(controller),
+      navigations_remaining_(number_of_navigations),
       navigation_started_(false) {
+    DCHECK_LT(0, navigations_remaining_);
     Source<NavigationController> source(controller_);
     registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED, source);
     registrar_.Add(this, NotificationType::LOAD_START, source);
     registrar_.Add(this, NotificationType::LOAD_STOP, source);
     registrar_.Add(this, NotificationType::AUTH_NEEDED, source);
     registrar_.Add(this, NotificationType::AUTH_SUPPLIED, source);
   }
 
   ~NavigationNotificationObserver() {
     if (reply_message_) {
@@ skipping 29 matching lines @@
     // WaitForNavigation compares times of the last navigation).
     // - when this is used with a page requiring authentication, we will not get
     // a NotificationType::NAV_ENTRY_COMMITTED until after we authenticate, so
     // we need the NotificationType::LOAD_START.
     if (type == NotificationType::NAV_ENTRY_COMMITTED ||
         type == NotificationType::LOAD_START) {
       navigation_started_ = true;
     } else if (type == NotificationType::LOAD_STOP) {
       if (navigation_started_) {
         navigation_started_ = false;
-        ConditionMet(AUTOMATION_MSG_NAVIGATION_SUCCESS);
+        if (--navigations_remaining_ == 0)
+          ConditionMet(AUTOMATION_MSG_NAVIGATION_SUCCESS);
       }
     } else if (type == NotificationType::AUTH_SUPPLIED) {
       // The LoginHandler for this tab is no longer valid.
       automation_->RemoveLoginHandler(controller_);
 
       // Treat this as if navigation started again, since load start/stop don't
       // occur while authentication is ongoing.
       navigation_started_ = true;
     } else if (type == NotificationType::AUTH_NEEDED) {
 #if defined(OS_WIN)
@@ skipping 16 matching lines @@
     } else {
       NOTREACHED();
     }
   }
 
  private:
   NotificationRegistrar registrar_;
   AutomationProvider* automation_;
   IPC::Message* reply_message_;
   NavigationController* controller_;
+  int navigations_remaining_;
   bool navigation_started_;
 };
 
 class TabStripNotificationObserver : public NotificationObserver {
  public:
   TabStripNotificationObserver(NotificationType notification,
                                AutomationProvider* automation)
       : automation_(automation),
         notification_(notification) {
     registrar_.Add(this, notification_, NotificationService::AllSources());
@@ skipping 35 matching lines @@
         reply_message_(reply_message) {
   }
 
   virtual void ObserveTab(NavigationController* controller) {
     if (automation_->GetIndexForNavigationController(controller, parent_) ==
         TabStripModel::kNoTab) {
       // This tab notification doesn't belong to the parent_.
       return;
     }
 
-    automation_->AddNavigationStatusListener(controller, reply_message_);
+    automation_->AddNavigationStatusListener(controller, reply_message_, 1);
   }
 
  protected:
   Browser* parent_;
   IPC::Message* reply_message_;
 };
 
 class TabClosedNotificationObserver : public TabStripNotificationObserver {
  public:
   TabClosedNotificationObserver(AutomationProvider* automation,
@@ skipping 153 matching lines @@
         TabClosedNotificationObserver* observer =
             new TabClosedNotificationObserver(automation, true, reply_message);
         observer->set_for_browser_command(true);
         break;
       }
       case IDC_BACK:
       case IDC_FORWARD:
       case IDC_RELOAD: {
         automation->AddNavigationStatusListener(
             &browser->GetSelectedTabContents()->controller(),
-            reply_message);
+            reply_message, 1);
         break;
       }
       default: {
         ExecuteBrowserCommandObserver* observer =
             new ExecuteBrowserCommandObserver(automation, reply_message);
         if (!observer->Register(command)) {
           delete observer;
           result = false;
         }
         break;
@@ skipping 267 matching lines @@
 
 void AutomationProvider::SetExpectedTabCount(size_t expected_tabs) {
   if (expected_tabs == 0) {
     Send(new AutomationMsg_InitialLoadsComplete(0));
   } else {
     initial_load_observer_.reset(new InitialLoadObserver(expected_tabs, this));
   }
 }
 
 NotificationObserver* AutomationProvider::AddNavigationStatusListener(
-    NavigationController* tab, IPC::Message* reply_message) {
+    NavigationController* tab, IPC::Message* reply_message,
+    int number_of_navigations) {
   NotificationObserver* observer =
-      new NavigationNotificationObserver(tab, this, reply_message);
+      new NavigationNotificationObserver(tab, this, reply_message,
+                                         number_of_navigations);
 
   notification_observer_list_.AddObserver(observer);
   return observer;
 }
 
 void AutomationProvider::RemoveNavigationStatusListener(
     NotificationObserver* obs) {
   notification_observer_list_.RemoveObserver(obs);
 }
 
@@ skipping 62 matching lines @@
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseBrowser, CloseBrowser)
     IPC_MESSAGE_HANDLER(AutomationMsg_CloseBrowserRequestAsync,
                         CloseBrowserAsync)
     IPC_MESSAGE_HANDLER(AutomationMsg_ActivateTab, ActivateTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_ActiveTabIndex, GetActiveTabIndex)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_AppendTab, AppendTab)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseTab, CloseTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetCookies, GetCookies)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetCookie, SetCookie)
     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_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)
@@ skipping 176 matching lines @@
     }
 
     AutomationMsg_AppendTab::WriteReplyParams(reply_message,
                                               append_tab_response);
     Send(reply_message);
   }
 }
 
 void AutomationProvider::NavigateToURL(int handle, const GURL& url,
                                        IPC::Message* reply_message) {
+  NavigateToURLBlockUntilNavigationsComplete(handle, url, 1, reply_message);
+}
+
+void AutomationProvider::NavigateToURLBlockUntilNavigationsComplete(
+    int handle, const GURL& url, int number_of_navigations,
+    IPC::Message* reply_message) {
   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) {
-      AddNavigationStatusListener(tab, reply_message);
+      AddNavigationStatusListener(tab, reply_message, number_of_navigations);
 
       // TODO(darin): avoid conversion to GURL
       browser->OpenURL(url, GURL(), CURRENT_TAB, PageTransition::TYPED);
       return;
     }
   }
 
   AutomationMsg_NavigateToURL::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
   Send(reply_message);
 }
-
 void AutomationProvider::NavigationAsync(int handle, const GURL& url,
                                          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(), CURRENT_TAB, 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);
+      AddNavigationStatusListener(tab, reply_message, 1);
       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);
+      AddNavigationStatusListener(tab, reply_message, 1);
       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);
+      AddNavigationStatusListener(tab, reply_message, 1);
       browser->Reload();
       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);
+      AddNavigationStatusListener(tab, reply_message, 1);
       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);
+      AddNavigationStatusListener(tab, reply_message, 1);
       handler->CancelAuth();
       return;
     }
   }
 
   AutomationMsg_CancelAuth::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED);
   Send(reply_message);
 }
 
@@ skipping 1016 matching lines @@
 }
 #endif  // defined(OS_WIN)
 
 void AutomationProvider::ShowInterstitialPage(int tab_handle,
                                               const std::string& html_text,
                                               IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
     NavigationController* controller = tab_tracker_->GetResource(tab_handle);
     TabContents* tab_contents = controller->tab_contents();
 
-    AddNavigationStatusListener(controller, reply_message);
+    AddNavigationStatusListener(controller, reply_message, 1);
     AutomationInterstitialPage* interstitial =
         new AutomationInterstitialPage(tab_contents,
                                        GURL("about:interstitial"),
                                        html_text);
     interstitial->Show();
     return;
   }
 
   AutomationMsg_ShowInterstitialPage::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
@@ skipping 177 matching lines @@
                                                  IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     NavigationEntry* entry = tab->GetActiveEntry();
     if (entry->page_type() == NavigationEntry::INTERSTITIAL_PAGE) {
       TabContents* tab_contents = tab->tab_contents();
       InterstitialPage* ssl_blocking_page =
           InterstitialPage::GetInterstitialPage(tab_contents);
       if (ssl_blocking_page) {
         if (proceed) {
-          AddNavigationStatusListener(tab, reply_message);
+          AddNavigationStatusListener(tab, reply_message, 1);
           ssl_blocking_page->Proceed();
           return;
         }
         ssl_blocking_page->DontProceed();
         AutomationMsg_ActionOnSSLBlockingPage::WriteReplyParams(
             reply_message, AUTOMATION_MSG_NAVIGATION_SUCCESS);
         Send(reply_message);
         return;
       }
     }
@@ skipping 284 matching lines @@
                                              int info_bar_index,
                                              bool wait_for_navigation,
                                              IPC::Message* reply_message) {
   bool success = false;
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* nav_controller = tab_tracker_->GetResource(handle);
     if (nav_controller) {
       int count = nav_controller->tab_contents()->infobar_delegate_count();
       if (info_bar_index >= 0 && info_bar_index < count) {
         if (wait_for_navigation) {
-          AddNavigationStatusListener(nav_controller, reply_message);
+          AddNavigationStatusListener(nav_controller, reply_message, 1);
         }
         InfoBarDelegate* delegate =
             nav_controller->tab_contents()->GetInfoBarDelegateAt(
                 info_bar_index);
         if (delegate->AsConfirmInfoBarDelegate())
           delegate->AsConfirmInfoBarDelegate()->Accept();
         success = true;
       }
     }
   }
@@ skipping 16 matching lines @@
     controller = tab_tracker_->GetResource(handle);
 
   Time time = tab_tracker_->GetLastNavigationTime(handle);
   if (time.ToInternalValue() > last_navigation_time || !controller) {
     AutomationMsg_WaitForNavigation::WriteReplyParams(reply_message,
         controller == NULL ? AUTOMATION_MSG_NAVIGATION_ERROR :
                              AUTOMATION_MSG_NAVIGATION_SUCCESS);
     return;
   }
 
-  AddNavigationStatusListener(controller, reply_message);
+  AddNavigationStatusListener(controller, reply_message, 1);
 }
 
 void AutomationProvider::SetIntPreference(int handle,
                                           const std::wstring& name,
                                           int value,
                                           bool* success) {
   *success = false;
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     browser->profile()->GetPrefs()->SetInteger(name.c_str(), value);
@@ skipping 237 matching lines @@
       NOTREACHED();
       return NULL;
     }
 
     RenderViewHost* view_host = tab_contents->render_view_host();
     return view_host;
   }
 
   return NULL;
 }