Create content\public\test\test_utils.h to hold common test classes that are used by unit and brows…

chrome/browser/tab_restore_browsertest.cc

 // Copyright (c) 2012 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 "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
@@ skipping 47 matching lines @@
           browser, url1_, NEW_FOREGROUND_TAB,
           ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
     }
     int tab_count = browser->tab_count();
     EXPECT_EQ(starting_tab_count + how_many, tab_count);
     return tab_count;
   }
 
   void CloseTab(int index) {
     content::WebContents* new_tab = chrome::GetWebContentsAt(browser(), index);
-    ui_test_utils::WindowedNotificationObserver tab_close_observer(
-          content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-          content::NotificationService::AllSources());
+    content::WindowedNotificationObserver tab_close_observer(
+        content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+        content::NotificationService::AllSources());
     chrome::CloseWebContents(browser(), new_tab);
     tab_close_observer.Wait();
   }
 
   // Uses the undo-close-tab accelerator to undo a close-tab or close-window
   // operation. The newly restored tab is expected to appear in the
   // window at index |expected_window_index|, at the |expected_tabstrip_index|,
   // and to be active. If |expected_window_index| is equal to the number of
   // current windows, the restored tab is expected to be created in a new
   // window (since the index is 0-based).
   void RestoreTab(int expected_window_index,
                   int expected_tabstrip_index) {
     int window_count = static_cast<int>(BrowserList::size());
     ASSERT_GT(window_count, 0);
 
     bool expect_new_window = (expected_window_index == window_count);
 
     Browser* browser;
     if (expect_new_window) {
       browser = *(BrowserList::begin());
     } else {
       browser = GetBrowser(expected_window_index);
     }
     int tab_count = browser->tab_count();
     ASSERT_GT(tab_count, 0);
 
     // Restore the tab.
-    ui_test_utils::WindowedNotificationObserver tab_added_observer(
-      chrome::NOTIFICATION_TAB_PARENTED,
-      content::NotificationService::AllSources());
-    ui_test_utils::WindowedNotificationObserver tab_loaded_observer(
-      content::NOTIFICATION_LOAD_STOP,
-      content::NotificationService::AllSources());
+    content::WindowedNotificationObserver tab_added_observer(
+        chrome::NOTIFICATION_TAB_PARENTED,
+        content::NotificationService::AllSources());
+    content::WindowedNotificationObserver tab_loaded_observer(
+        content::NOTIFICATION_LOAD_STOP,
+        content::NotificationService::AllSources());
     chrome::RestoreTab(browser);
     tab_added_observer.Wait();
     tab_loaded_observer.Wait();
 
     if (expect_new_window) {
       int new_window_count = static_cast<int>(BrowserList::size());
       EXPECT_EQ(++window_count, new_window_count);
       browser = GetBrowser(expected_window_index);
     } else {
       EXPECT_EQ(++tab_count, browser->tab_count());
     }
 
     // Get a handle to the restored tab.
     ASSERT_GT(browser->tab_count(), expected_tabstrip_index);
 
     // Ensure that the tab and window are active.
     EXPECT_EQ(expected_tabstrip_index, browser->active_index());
   }
 
   void GoBack(Browser* browser) {
-    ui_test_utils::WindowedNotificationObserver observer(
+    content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     chrome::GoBack(browser, CURRENT_TAB);
     observer.Wait();
   }
 
   void EnsureTabFinishedRestoring(content::WebContents* tab) {
     content::NavigationController* controller = &tab->GetController();
     if (!controller->NeedsReload() && !controller->GetPendingEntry() &&
         !controller->GetWebContents()->IsLoading())
       return;
 
-    ui_test_utils::WindowedNotificationObserver observer(
+    content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<content::NavigationController>(controller));
     observer.Wait();
   }
 
   GURL url1_;
   GURL url2_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TabRestoreTest);
@@ skipping 70 matching lines @@
   ui_test_utils::NavigateToURL(browser(), url1_);
   ui_test_utils::NavigateToURL(browser(), url2_);
 
   // Create a new browser.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
   EXPECT_EQ(2u, BrowserList::size());
 
   // Close the final tab in the first browser.
-  ui_test_utils::WindowedNotificationObserver window_observer(
+  content::WindowedNotificationObserver window_observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   CloseTab(0);
   window_observer.Wait();
 
   ASSERT_NO_FATAL_FAILURE(RestoreTab(1, 0));
 
   // Tab should be in a new window.
   Browser* browser = GetBrowser(1);
   content::WebContents* web_contents = chrome::GetActiveWebContents(browser);
@@ skipping 33 matching lines @@
   CloseTab(closed_tab_index);
   EXPECT_EQ(starting_tab_count + 2, browser()->tab_count());
 
   // Create a new browser.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
   EXPECT_EQ(2u, BrowserList::size());
 
   // Close the first browser.
-  ui_test_utils::WindowedNotificationObserver observer(
+  content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   chrome::CloseWindow(browser());
   observer.Wait();
   EXPECT_EQ(1u, BrowserList::size());
 
   // Restore the first window. The expected_tabstrip_index (second argument)
   // indicates the expected active tab.
   ASSERT_NO_FATAL_FAILURE(RestoreTab(1, starting_tab_count + 1));
   Browser* browser = GetBrowser(1);
@@ skipping 20 matching lines @@
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
   EXPECT_EQ(2u, BrowserList::size());
 
   // Close all but one tab in the first browser, left to right.
   while (browser()->tab_count() > 1)
     CloseTab(0);
 
   // Close the last tab, closing the browser.
-  ui_test_utils::WindowedNotificationObserver observer(
+  content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   CloseTab(0);
   observer.Wait();
   EXPECT_EQ(1u, BrowserList::size());
 
   // Restore the last-closed tab into a new window.
   ASSERT_NO_FATAL_FAILURE(RestoreTab(1, 0));
   Browser* browser = GetBrowser(1);
   EXPECT_EQ(1, browser->tab_count());
@@ skipping 16 matching lines @@
 
   // Add a tab
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), http_url1, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_EQ(++tab_count, browser()->tab_count());
 
   // Navigate to another same-site URL.
   content::WebContents* tab =
       chrome::GetWebContentsAt(browser(), tab_count - 1);
-  ui_test_utils::WindowedNotificationObserver observer(
+  content::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
       content::NotificationService::AllSources());
   static_cast<content::WebContentsDelegate*>(browser())->OpenURLFromTab(
       tab,
       content::OpenURLParams(http_url2, content::Referrer(), CURRENT_TAB,
                              content::PAGE_TRANSITION_TYPED, false));
   observer.Wait();
 
   // Close the tab.
   CloseTab(1);
@@ skipping 81 matching lines @@
   // Create two more tabs, one with url1, the other url2.
   int initial_tab_count = browser()->tab_count();
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url1_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url2_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Close the window.
-  ui_test_utils::WindowedNotificationObserver close_window_observer(
+  content::WindowedNotificationObserver close_window_observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   chrome::CloseWindow(browser());
   close_window_observer.Wait();
   EXPECT_EQ(window_count - 1, BrowserList::size());
 
   // Restore the window.
-  ui_test_utils::WindowedNotificationObserver open_window_observer(
+  content::WindowedNotificationObserver open_window_observer(
       chrome::NOTIFICATION_BROWSER_OPENED,
       content::NotificationService::AllSources());
-  ui_test_utils::WindowedNotificationObserver load_stop_observer(
+  content::WindowedNotificationObserver load_stop_observer(
       content::NOTIFICATION_LOAD_STOP,
       content::NotificationService::AllSources());
   chrome::RestoreTab(*BrowserList::begin());
   open_window_observer.Wait();
   EXPECT_EQ(window_count, BrowserList::size());
 
   Browser* browser = GetBrowser(1);
   EXPECT_EQ(initial_tab_count + 2, browser->tab_count());
   load_stop_observer.Wait();
 
@@ skipping 52 matching lines @@
   TabContents* tab = chrome::GetTabContentsAt(browser(), 1);
   EnsureTabFinishedRestoring(tab->web_contents());
   ASSERT_EQ(http_url, tab->web_contents()->GetURL());
 
   // Go back, and see if content is as expected.
   GoBack(browser());
   EXPECT_GT(
       ui_test_utils::FindInPage(tab, ASCIIToUTF16("webkit"), true, false, NULL),
       0);
 }