ui_test_utils::NavigateToURLBlockUntilNavigationsComplete can be raced

chrome/test/ui_test_utils.cc

 // Copyright (c) 2011 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/test/ui_test_utils.h"
 
 #include <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 43 matching lines @@
 
 namespace {
 
 // Used to block until a navigation completes.
 class NavigationNotificationObserver : public NotificationObserver {
  public:
   NavigationNotificationObserver(NavigationController* controller,
                                  int number_of_navigations)
       : navigation_started_(false),
         navigations_completed_(0),
-        number_of_navigations_(number_of_navigations) {
+        number_of_navigations_(number_of_navigations),
+        running_(false),
+        done_(false) {
     registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                    Source<NavigationController>(controller));
     registrar_.Add(this, NotificationType::LOAD_START,
                    Source<NavigationController>(controller));
     registrar_.Add(this, NotificationType::LOAD_STOP,
                    Source<NavigationController>(controller));
-    RunMessageLoop();
+  }
+
+  void Run() {
+    if (!done_) {
+      running_ = true;
+      RunMessageLoop();
+    }
   }
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     if (type == NotificationType::NAV_ENTRY_COMMITTED ||
         type == NotificationType::LOAD_START) {
       navigation_started_ = true;
     } else if (type == NotificationType::LOAD_STOP) {
       if (navigation_started_ &&
           ++navigations_completed_ == number_of_navigations_) {
         navigation_started_ = false;
-        MessageLoopForUI::current()->Quit();
+        done_ = true;
+        if (running_)
+          MessageLoopForUI::current()->Quit();
       }
     }
   }
 
  private:
   NotificationRegistrar registrar_;
 
   // If true the navigation has started.
   bool navigation_started_;
 
   // The number of navigations that have been completed.
   int navigations_completed_;
 
   // The number of navigations to wait for.
   int number_of_navigations_;
 
+  // Calls to Observe() can happen early, before the user calls Run(), or
+  // after.  When we've seen all the navigations we're looking for, we set
+  // done_ to true; then when Run() is called we'll never need to run the
+  // event loop.  Also, we don't need to quit the event loop when we're
+  // done if we never had to start an event loop.
+  bool running_;
+  bool done_;
   DISALLOW_COPY_AND_ASSIGN(NavigationNotificationObserver);
 };
 
 class DOMOperationObserver : public NotificationObserver {
  public:
   explicit DOMOperationObserver(RenderViewHost* render_view_host)
       : did_respond_(false) {
     registrar_.Add(this, NotificationType::DOM_OPERATION_RESPONSE,
                    Source<RenderViewHost>(render_view_host));
     ui_test_utils::RunMessageLoop();
@@ skipping 294 matching lines @@
   return true;
 }
 
 void WaitForNavigation(NavigationController* controller) {
   WaitForNavigations(controller, 1);
 }
 
 void WaitForNavigations(NavigationController* controller,
                         int number_of_navigations) {
   NavigationNotificationObserver observer(controller, number_of_navigations);
+  observer.Run();
 }
 
 void WaitForNewTab(Browser* browser) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, NotificationType::TAB_ADDED,
                   Source<Browser>(browser));
 }
 
 void WaitForBrowserActionUpdated(ExtensionAction* browser_action) {
   TestNotificationObserver observer;
@@ skipping 40 matching lines @@
 // Navigates the specified tab (via |disposition|) of |browser| to |url|,
 // blocking until the |number_of_navigations| specified complete.
 // |disposition| indicates what tab the download occurs in, and
 // |browser_test_flags| controls what to wait for before continuing.
 static void NavigateToURLWithDispositionBlockUntilNavigationsComplete(
     Browser* browser,
     const GURL& url,
     int number_of_navigations,
     WindowOpenDisposition disposition,
     int browser_test_flags) {
+  NavigationNotificationObserver
+      same_tab_observer(&browser->GetSelectedTabContents()->controller(),
+                        number_of_navigations);
+
   std::set<Browser*> initial_browsers;
   for (std::vector<Browser*>::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end();
        ++iter) {
     initial_browsers.insert(*iter);
   }
   browser->OpenURL(url, GURL(), disposition, PageTransition::TYPED);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_BROWSER)
     browser = WaitForBrowserNotInSet(initial_browsers);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_TAB)
     WaitForNotification(NotificationType::TAB_ADDED);
   if (!(browser_test_flags & BROWSER_TEST_WAIT_FOR_NAVIGATION)) {
     // Some other flag caused the wait prior to this.
     return;
   }
   TabContents* tab_contents = NULL;
   if (disposition == NEW_BACKGROUND_TAB) {
     // We've opened up a new tab, but not selected it.
     tab_contents = browser->GetTabContentsAt(browser->selected_index() + 1);
     EXPECT_TRUE(tab_contents != NULL)
         << " Unable to wait for navigation to \"" << url.spec()
         << "\" because the new tab is not available yet";
     return;
   } else if ((disposition == CURRENT_TAB) ||
       (disposition == NEW_FOREGROUND_TAB) ||
       (disposition == SINGLETON_TAB)) {
     // The currently selected tab is the right one.
     tab_contents = browser->GetSelectedTabContents();
   }
-  if (tab_contents) {
+  if (disposition == CURRENT_TAB) {
+    same_tab_observer.Run();
+    return;
+  } else if (tab_contents) {
     NavigationController* controller = &tab_contents->controller();
     WaitForNavigations(controller, number_of_navigations);
     return;
   }
   EXPECT_TRUE(NULL != tab_contents) << " Unable to wait for navigation to \""
                                     << url.spec() << "\""
                                     << " because we can't get the tab contents";
 }
 
 void NavigateToURLWithDisposition(Browser* browser,
@@ skipping 530 matching lines @@
   return taker.TakeRenderWidgetSnapshot(rwh, page_size, page_size, bitmap);
 }
 
 bool TakeEntirePageSnapshot(RenderViewHost* rvh, SkBitmap* bitmap) {
   DCHECK(bitmap);
   SnapshotTaker taker;
   return taker.TakeEntirePageSnapshot(rvh, bitmap);
 }
 
 }  // namespace ui_test_utils