Added options browser_tests using the generator and js handler framework.

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 17 matching lines @@
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/find_bar/find_notification_details.h"
 #include "chrome/browser/ui/find_bar/find_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/test/automation/javascript_execution_controller.h"
 #include "chrome/test/bookmark_load_observer.h"
+#include "chrome/test/test_navigation_observer.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.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"
 #include "ui/gfx/size.h"
 
 #if defined(TOOLKIT_VIEWS)
 #include "views/focus/accelerator_handler.h"
 #endif
 
 namespace ui_test_utils {
 
 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),
-        running_(false),
-        done_(false) {
-    registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-                   Source<NavigationController>(controller));
-    registrar_.Add(this, content::NOTIFICATION_LOAD_START,
-                   Source<NavigationController>(controller));
-    registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
-                   Source<NavigationController>(controller));
-  }
-
-  void Run() {
-    if (!done_) {
-      running_ = true;
-      RunMessageLoop();
-    }
-  }
-
-  virtual void Observe(int type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details) {
-    if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED ||
-        type == content::NOTIFICATION_LOAD_START) {
-      navigation_started_ = true;
-    } else if (type == content::NOTIFICATION_LOAD_STOP) {
-      if (navigation_started_ &&
-          ++navigations_completed_ == number_of_navigations_) {
-        navigation_started_ = false;
-        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, chrome::NOTIFICATION_DOM_OPERATION_RESPONSE,
                    Source<RenderViewHost>(render_view_host));
     ui_test_utils::RunMessageLoop();
   }
 
   virtual void Observe(int type,
@@ skipping 198 matching lines @@
   WaitForNavigations(&tab_contents->controller(), number_of_navigations);
   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();
+  TestNavigationObserver observer(controller, NULL, number_of_navigations);
+  observer.WaitForObservation();
 }
 
 void WaitForNewTab(Browser* browser) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, content::NOTIFICATION_TAB_ADDED,
                   Source<Browser>(browser));
 }
 
 void WaitForBrowserActionUpdated(ExtensionAction* browser_action) {
   TestNotificationObserver observer;
@@ skipping 45 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
+  TestNavigationObserver
       same_tab_observer(&browser->GetSelectedTabContents()->controller(),
-                        number_of_navigations);
+                        NULL, 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);
@@ skipping 11 matching lines @@
         << " 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 (disposition == CURRENT_TAB) {
-    same_tab_observer.Run();
+    same_tab_observer.WaitForObservation();
     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";
 }
@@ skipping 581 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