Converted download UI tests to Browser tests.

chrome/test/ui_test_utils.h

 // 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.
 
 #ifndef CHROME_TEST_UI_TEST_UTILS_H_
 #define CHROME_TEST_UI_TEST_UTILS_H_
 #pragma once
 
 #include <map>
 #include <queue>
 #include <string>
 #include <set>
 
 #include "app/keyboard_codes.h"
 #include "base/basictypes.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string16.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/test/automation/dom_element_proxy.h"
 #include "gfx/native_widget_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/glue/window_open_disposition.h"
 
 class AppModalDialog;
 class BookmarkModel;
 class BookmarkNode;
 class Browser;
 class CommandLine;
 class DownloadManager;
 class ExtensionAction;
 class FilePath;
 class GURL;
 class MessageLoop;
 class NavigationController;
 class NotificationType;
 class Profile;
 class RenderViewHost;
 class RenderWidgetHost;
 class ScopedTempDir;
 class SkBitmap;
 class TabContents;
 class Value;
 
 namespace gfx {
 class Size;
 }
 
 // A collections of functions designed for use with InProcessBrowserTest.
 namespace ui_test_utils {
 
+// Flags to indicate what to wait for in a navigation test.
+// They can be ORed together.
+// The order in which the waits happen when more than one is selected, is:
+//    Browser
+//    Tab
+//    Navigation
+enum BrowserTestFlags {
+  BROWSER_TEST_NONE = 0,                      // Don't wait for anything.
+  BROWSER_TEST_WAIT_FOR_BROWSER = 1 << 0,     // Wait for a new browser.
+  BROWSER_TEST_WAIT_FOR_TAB = 1 << 1,         // Wait for a new tab.

[Randy Smith (Not in Mondays), 2010/12/13 21:44:58]

So just confirming: If I WAIT_FOR_TAB but don't WAIT_FOR_NAVIGATION, the wait
will return when the tab is created but before any specified navigation occurs?

[ahendrickson, 2010/12/16 19:26:41]

Correct.

+  BROWSER_TEST_WAIT_FOR_NAVIGATION = 1 << 2,  // Wait for navigation to finish.
+
+  BROWSER_TEST_MASK = BROWSER_TEST_WAIT_FOR_BROWSER |
+                      BROWSER_TEST_WAIT_FOR_TAB |
+                      BROWSER_TEST_WAIT_FOR_NAVIGATION
+};
+
 // Turns on nestable tasks, runs the message loop, then resets nestable tasks
 // to what they were originally. Prefer this over MessageLoop::Run for in
 // process browser tests that need to block until a condition is met.
 void RunMessageLoop();
 
 // Turns on nestable tasks, runs all pending tasks in the message loop,
 // then resets nestable tasks to what they were originally. Prefer this
 // over MessageLoop::RunAllPending for in process browser tests to run
 // all pending tasks.
 void RunAllPendingInMessageLoop();
@@ skipping 12 matching lines @@
 
 // Waits for |controller| to complete a navigation. This blocks until
 // the navigation finishes.
 void WaitForNavigation(NavigationController* controller);
 
 // Waits for |controller| to complete a navigation. This blocks until
 // the specified number of navigations complete.
 void WaitForNavigations(NavigationController* controller,
                         int number_of_navigations);
 
+// Waits for the |browser| to close its window.
+void WaitForWindowClosed(Browser* browser);
+
+// Waits for a new tab to be added anywhere.
+Browser* WaitForAnyNewTab();

[Randy Smith (Not in Mondays), 2010/12/13 21:44:58]

This is only used in one place, which is inside ui_test_utils.cc; it should
probably be declared and defined in an anonymous namespace in that file.  Ditto
for WaitForNewBrowserWithCount().  Ditto for
NavigateToURLWithDispositionBlockUntilNavigationComplete() (used twice, but both
in ui_test_utils.cc).

[ahendrickson, 2010/12/16 19:26:41]

Moved.  I do think it could be used by other files though.

+
 // Waits for a new tab to be added to |browser|.
 void WaitForNewTab(Browser* browser);
 
 // Waits for a |browser_action| to be updated.
 void WaitForBrowserActionUpdated(ExtensionAction* browser_action);
 
 // Waits for a load stop for the specified |controller|.
 void WaitForLoadStop(NavigationController* controller);
 
 // Waits for a new browser to be created, returning the browser.
 Browser* WaitForNewBrowser();
 
+// Waits for a new browser to be created, returning the browser.
+// Pass in the number of browsers that exist before the navigation starts in
+// |start_count|, and it will exit even if the notification occurs before it's
+// called.
+Browser* WaitForNewBrowserWithCount(size_t start_count);
+
 // Opens |url| in an incognito browser window with the off the record profile of
 // |profile|, blocking until the navigation finishes. This will create a new
 // browser if a browser with the off the record profile does not exist.
 void OpenURLOffTheRecord(Profile* profile, const GURL& url);
 
 // Navigates the selected tab of |browser| to |url|, blocking until the
 // navigation finishes.
 void NavigateToURL(Browser* browser, const GURL& url);
 
+// Navigates the specified tab of |browser| to |url|, blocking until the
+// navigation finishes.
+// |disposition| indicates what tab the download occurs in, and

[Randy Smith (Not in Mondays), 2010/12/13 21:44:58]

nit: This call isn't about downloads specifically.

[ahendrickson, 2010/12/16 19:26:41]

Done.

+// |browser_test_flags| controls what to wait for before continuing.
+void NavigateToURLWithDisposition(Browser* browser,
+                                  const GURL& url,
+                                  WindowOpenDisposition disposition,
+                                  int browser_test_flags);
+
 // Navigates the selected tab of |browser| to |url|, blocking until the
 // number of navigations specified complete.
 void NavigateToURLBlockUntilNavigationsComplete(Browser* browser,
                                                 const GURL& url,
                                                 int number_of_navigations);
 
+// Navigates the specified tab (via |disposition|) of |browser| to |url|,
+// blocking until the |number_of_navigations| specified complete.

[Randy Smith (Not in Mondays), 2010/12/13 21:44:58]

This is a bit confusing, at least to an untutored eye.  How can a URL imply more
than one navigation?  Or to put it differently, what does a single navigation
consist of?

[ahendrickson, 2010/12/16 19:26:41]

Yeah, I found it a bit odd too -- I copied the comment  from
|NavigateToURLBlockUntilNavigationsComplete|.

One possibility is that a navigation might cause other navigations to occur (for
example, if the URL is a Javascript call).

+// |disposition| indicates what tab the download occurs in, and
+// |browser_test_flags| controls what to wait for before continuing.
+void NavigateToURLWithDispositionBlockUntilNavigationsComplete(
+    Browser* browser,
+    const GURL& url,
+    int number_of_navigations,
+    WindowOpenDisposition disposition,
+    int browser_test_flags);
+
 // Gets the DOMDocument for the active tab in |browser|.
 // Returns a NULL reference on failure.
 DOMElementProxyRef GetActiveDOMDocument(Browser* browser);
 
 // Executes the passed |script| in the frame pointed to by |frame_xpath| (use
 // empty string for main frame).  The |script| should not invoke
 // domAutomationController.send(); otherwise, your test will hang or be flaky.
 // If you want to extract a result, use one of the below functions.
 // Returns true on success.
 bool ExecuteJavaScript(RenderViewHost* render_view_host,
@@ skipping 81 matching lines @@
 
 // Puts the native window for |browser| in |native_window|. Returns true on
 // success.
 bool GetNativeWindow(const Browser* browser, gfx::NativeWindow* native_window)
     WARN_UNUSED_RESULT;
 
 // Brings the native window for |browser| to the foreground. Returns true on
 // success.
 bool BringBrowserWindowToFront(const Browser* browser) WARN_UNUSED_RESULT;
 
+// Gets the browser at the specified |index|.
+Browser* GetBrowser(int index);
+
 // Sends a key press, blocking until the key press is received or the test times
 // out. This uses ui_controls::SendKeyPress, see it for details. Returns true
 // if the event was successfully sent and received.
 bool SendKeyPressSync(const Browser* browser,
                       app::KeyboardCode key,
                       bool control,
                       bool shift,
                       bool alt,
                       bool command) WARN_UNUSED_RESULT;
 
@@ skipping 282 matching lines @@
 
 // Takes a snapshot of the entire page, according to the width and height
 // properties of the DOM's document. Returns true on success. DOMAutomation
 // must be enabled.
 bool TakeEntirePageSnapshot(RenderViewHost* rvh,
                             SkBitmap* bitmap) WARN_UNUSED_RESULT;
 
 }  // namespace ui_test_utils
 
 #endif  // CHROME_TEST_UI_TEST_UTILS_H_