Converted download UI tests to Browser tests.

chrome/test/ui_test_utils.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/test/ui_test_utils.h"
 
 #include <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 30 matching lines @@
 #endif
 #include "gfx/size.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace ui_test_utils {
 
+// 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.
+void NavigateToURLWithDispositionBlockUntilNavigationsComplete(

[Paweł Hajdan Jr., 2011/01/06 20:45:48]

nit: This forward-declaration is really weird and doesn't seem to be needed. Can
we get rid of it?

[ahendrickson, 2011/01/06 22:33:39]

IIRC, it's required for GCC compilation.

+    Browser* browser,
+    const GURL& url,
+    int number_of_navigations,
+    WindowOpenDisposition disposition,
+    int browser_test_flags);
+
 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) {
@@ skipping 361 matching lines @@
 void WaitForLoadStop(NavigationController* controller) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, NotificationType::LOAD_STOP,
                   Source<NavigationController>(controller));
 }
 
 Browser* WaitForNewBrowser() {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, NotificationType::BROWSER_WINDOW_READY,
                   NotificationService::AllSources());
-  return Source<Browser>(observer.source()).ptr();
+  Browser* new_browser = Source<Browser>(observer.source()).ptr();

[Paweł Hajdan Jr., 2011/01/06 20:45:48]

nit: Why not just return Source ... ?

[ahendrickson, 2011/01/06 22:33:39]

Done.

+  return new_browser;
+}
+
+Browser* WaitForBrowserNotInSet(std::set<Browser*> excluded_browsers) {
+  TestNotificationObserver observer;
+  Browser* new_browser = GetBrowserNotInSet(excluded_browsers);
+  if (new_browser == NULL) {

[Paweł Hajdan Jr., 2011/01/06 20:45:48]

nit: if (!new_browser), no braces {}

[ahendrickson, 2011/01/06 22:33:39]

Done.

+    new_browser = WaitForNewBrowser();

[Paweł Hajdan Jr., 2011/01/06 20:45:48]

Should we somehow check it's not in |excluded_browsers|?

[ahendrickson, 2011/01/06 22:33:39]

For what I'm doing, it's not an issue.

My understanding is that there is some time between the browser being created
and the BROWSER_WINDOW_READY signal.  We check for the existence of a new
browser first, and then wait for the signal if it doesn't exist yet.  However,
the way we use it is to wait until the previous window is finished before
opening a new one, so only the new window should trigger the wait.

[Randy Smith (Not in Mondays), 2011/01/06 23:27:35]

Yeah, but if it's in ui_test_utils.cc, it should behave generally, not just for
our purposes.  I'm not sure I see a pathway in which we could pass in a browser
pointer to exclude that hasn't yet made it into the global browser list, but if
we do (e.g. if we make the change that was being talked about on your other CL
to not return browser pointers without windows from the browser list) this
routine should be resilient against that.  I.e. at least based on my current
understanding of this routine and the browser list infrastructure, I think we
should make sure the browser returned from WaitForNewBrowser() isn't in the set
of excluded browsers.  If you are pretty sure that should never happen, a DCHECK
would be fine, but if you can see some pathway in the future that might cause it
to happen, code it completely now and save someone some pain.

+  }
+  return new_browser;
 }
 
 void OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Browser::OpenURLOffTheRecord(profile, url);
   Browser* browser = BrowserList::FindBrowserWithType(
       profile->GetOffTheRecordProfile(), Browser::TYPE_NORMAL, false);
   WaitForNavigations(&browser->GetSelectedTabContents()->controller(), 1);
 }
 
 void NavigateToURL(Browser* browser, const GURL& url) {
-  NavigateToURLBlockUntilNavigationsComplete(browser, url, 1);
+  NavigateToURLWithDisposition(browser, url, CURRENT_TAB,
+                               BROWSER_TEST_WAIT_FOR_NAVIGATION);
+}
+
+void NavigateToURLWithDisposition(Browser* browser,
+                                  const GURL& url,
+                                  WindowOpenDisposition disposition,
+                                  int browser_test_flags) {
+  NavigateToURLWithDispositionBlockUntilNavigationsComplete(
+      browser,
+      url,
+      1,
+      disposition,
+      browser_test_flags);
 }
 
 void NavigateToURLBlockUntilNavigationsComplete(Browser* browser,
                                                 const GURL& url,
                                                 int number_of_navigations) {
-  NavigationController* controller =
-      &browser->GetSelectedTabContents()->controller();
-  browser->OpenURL(url, GURL(), CURRENT_TAB, PageTransition::TYPED);
-  WaitForNavigations(controller, number_of_navigations);
+  NavigateToURLWithDispositionBlockUntilNavigationsComplete(
+      browser,
+      url,
+      number_of_navigations,
+      CURRENT_TAB,
+      BROWSER_TEST_WAIT_FOR_NAVIGATION);
+}
+
+void NavigateToURLWithDispositionBlockUntilNavigationsComplete(
+    Browser* browser,
+    const GURL& url,
+    int number_of_navigations,
+    WindowOpenDisposition disposition,
+    int browser_test_flags) {
+  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) {
+    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";
 }
 
 DOMElementProxyRef GetActiveDOMDocument(Browser* browser) {
   JavaScriptExecutionController* executor =
       new InProcessJavaScriptExecutionController(
           browser->GetSelectedTabContents()->render_view_host());
   int element_handle;
   executor->ExecuteJavaScriptAndGetReturn("document;", &element_handle);
   return executor->GetObjectProxy<DOMElementProxy>(element_handle);
 }
@@ skipping 93 matching lines @@
   if (ordinal)
     *ordinal = observer.active_match_ordinal();
   return observer.number_of_matches();
 }
 
 void WaitForNotification(NotificationType type) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, type, NotificationService::AllSources());
 }
 
+void WaitForNotificationFrom(NotificationType type,
+                             const NotificationSource& source) {
+  TestNotificationObserver observer;
+  RegisterAndWait(&observer, type, source);
+}
+
 void RegisterAndWait(NotificationObserver* observer,
                      NotificationType type,
                      const NotificationSource& source) {
   NotificationRegistrar registrar;
   registrar.Add(observer, type, source);
   RunMessageLoop();
 }
 
 void WaitForBookmarkModelToLoad(BookmarkModel* model) {
   if (model->IsLoaded())
@@ skipping 23 matching lines @@
 
 bool BringBrowserWindowToFront(const Browser* browser) {
   gfx::NativeWindow window = NULL;
   if (!GetNativeWindow(browser, &window))
     return false;
 
   ui_test_utils::ShowAndFocusNativeWindow(window);
   return true;
 }
 
+Browser* GetBrowserNotInSet(std::set<Browser*> excluded_browsers) {
+  for (BrowserList::const_iterator iter = BrowserList::begin();
+       iter != BrowserList::end();
+       ++iter) {
+    if (excluded_browsers.find(*iter) == excluded_browsers.end())
+      return *iter;
+  }
+
+  return NULL;
+}
+
 bool SendKeyPressSync(const Browser* browser,
                       app::KeyboardCode key,
                       bool control,
                       bool shift,
                       bool alt,
                       bool command) {
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   gfx::NativeWindow window = NULL;
   if (!GetNativeWindow(browser, &window))
@@ skipping 293 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