Convert the history pyauto tests to a browser_tests.

chrome/browser/history/history_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 <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
 
@@ skipping 37 matching lines @@
   }
 
   PrefService* GetPrefs() {
     return GetProfile()->GetPrefs();
   }
 
   Profile* GetProfile() {
     return browser()->profile();
   }
 
-  HistoryService* GetHistoryService() {
-    return HistoryServiceFactory::GetForProfile(GetProfile(),
-                                                Profile::EXPLICIT_ACCESS);
-  }
-
   std::vector<GURL> GetHistoryContents() {
-    ui_test_utils::HistoryEnumerator enumerator(GetHistoryService());
+    ui_test_utils::HistoryEnumerator enumerator(GetProfile());
     return enumerator.urls();
   }
 
   GURL GetTestUrl() {
     return ui_test_utils::GetTestUrl(
         FilePath(FilePath::kCurrentDirectory),
         FilePath(FILE_PATH_LITERAL("title2.html")));
   }
 
   void WaitForHistoryBackendToRun() {
     CancelableRequestConsumerTSimple<int> request_consumer;
     scoped_refptr<HistoryDBTask> task(new WaitForHistoryTask());
-    HistoryService* history = GetHistoryService();
+    HistoryService* history =
+        HistoryServiceFactory::GetForProfile(GetProfile(),
+                                                Profile::EXPLICIT_ACCESS);
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&HistoryService::ScheduleDBTask,
                                        history, task, &request_consumer));
     content::RunMessageLoop();
   }
 
   void ExpectEmptyHistory() {
     std::vector<GURL> urls(GetHistoryContents());
     EXPECT_EQ(0U, urls.size());
@@ skipping 169 matching lines @@
   // Mainly, this is to ensure we send a synchronous message to the renderer
   // so that we're not susceptible (less susceptible?) to a race condition.
   // Should a race condition ever trigger, it won't result in flakiness.
   int num = ui_test_utils::FindInPage(
       chrome::GetActiveTabContents(browser()), ASCIIToUTF16("<img"), true,
       true, NULL, NULL);
   EXPECT_GT(num, 0);
   EXPECT_EQ(ASCIIToUTF16("History"),
             chrome::GetActiveWebContents(browser())->GetTitle());
 }
+
+// Verify that history persists after session restart.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, PRE_HistoryPersists) {
+  ui_test_utils::NavigateToURL(browser(), GetTestUrl());
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(1u, urls.size());
+  ASSERT_EQ(GetTestUrl(), urls[0]);
+}
+
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, HistoryPersists) {
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(1u, urls.size());
+  ASSERT_EQ(GetTestUrl(), urls[0]);
+}
+
+// Invalid URLs should not go in history.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, InvalidURLNoHistory) {
+  GURL non_existant = ui_test_utils::GetTestUrl(
+      FilePath().AppendASCII("History"),
+      FilePath().AppendASCII("non_existant_file.html"));
+  ui_test_utils::NavigateToURL(browser(), non_existant);
+  ExpectEmptyHistory();
+}
+
+// New tab page should not show up in history.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, NewTabNoHistory) {
+  ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUINewTabURL));
+  ExpectEmptyHistory();
+}
+
+// Incognito browsing should not show up in history.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, IncognitoNoHistory) {
+  ui_test_utils::NavigateToURL(CreateIncognitoBrowser(), GetTestUrl());
+  ExpectEmptyHistory();
+}
+
+// Multiple navigations to the same url should have a single history.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, NavigateMultiTimes) {
+  ui_test_utils::NavigateToURL(browser(), GetTestUrl());
+  ui_test_utils::NavigateToURL(browser(), GetTestUrl());
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(1u, urls.size());
+  ASSERT_EQ(GetTestUrl(), urls[0]);
+}
+
+// Verify history with multiple windows and tabs.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, MultiTabsWindowsHistory) {
+  GURL url1 = GetTestUrl();
+  GURL url2  = ui_test_utils::GetTestUrl(
+      FilePath(), FilePath(FILE_PATH_LITERAL("title1.html")));
+  GURL url3  = ui_test_utils::GetTestUrl(
+      FilePath(), FilePath(FILE_PATH_LITERAL("title3.html")));
+  GURL url4  = ui_test_utils::GetTestUrl(
+      FilePath(), FilePath(FILE_PATH_LITERAL("simple.html")));
+
+  ui_test_utils::NavigateToURL(browser(), url1);
+  Browser* browser2 = CreateBrowser(browser()->profile());
+  ui_test_utils::NavigateToURL(browser2, url2);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser2, url3, NEW_FOREGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser2, url4, NEW_FOREGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(4u, urls.size());
+  ASSERT_EQ(url4, urls[0]);
+  ASSERT_EQ(url3, urls[1]);
+  ASSERT_EQ(url2, urls[2]);
+  ASSERT_EQ(url1, urls[3]);
+}
+
+// Downloaded URLs should not show up in history.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, DownloadNoHistory) {
+  GURL download_url = ui_test_utils::GetTestUrl(
+      FilePath().AppendASCII("downloads"),
+      FilePath().AppendASCII("a_zip_file.zip"));
+  ui_test_utils::DownloadURL(browser(), download_url);
+  ExpectEmptyHistory();
+}
+
+// HTTP meta-refresh redirects should have separate history entries.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, RedirectHistory) {
+  GURL redirector = ui_test_utils::GetTestUrl(
+      FilePath().AppendASCII("History"),
+      FilePath().AppendASCII("redirector.html"));
+  GURL landing_url = ui_test_utils::GetTestUrl(
+      FilePath().AppendASCII("History"),
+      FilePath().AppendASCII("landing.html"));
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+      browser(), redirector, 2);
+  ASSERT_EQ(landing_url, chrome::GetActiveWebContents(browser())->GetURL());
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(2u, urls.size());
+  ASSERT_EQ(landing_url, urls[0]);
+  ASSERT_EQ(redirector, urls[1]);
+}
+
+// Verify that navigation brings current page to top of history list.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, NavigateBringPageToTop) {
+  GURL url1 = GetTestUrl();
+  GURL url2  = ui_test_utils::GetTestUrl(
+      FilePath(), FilePath(FILE_PATH_LITERAL("title3.html")));
+
+  ui_test_utils::NavigateToURL(browser(), url1);
+  ui_test_utils::NavigateToURL(browser(), url2);
+
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(2u, urls.size());
+  ASSERT_EQ(url2, urls[0]);
+  ASSERT_EQ(url1, urls[1]);
+}
+
+// Verify that reloading a page brings it to top of history list.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, ReloadBringPageToTop) {
+  GURL url1 = GetTestUrl();
+  GURL url2  = ui_test_utils::GetTestUrl(
+      FilePath(), FilePath(FILE_PATH_LITERAL("title3.html")));
+
+  ui_test_utils::NavigateToURL(browser(), url1);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(), url2, NEW_BACKGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(2u, urls.size());
+  ASSERT_EQ(url2, urls[0]);
+  ASSERT_EQ(url1, urls[1]);
+
+  content::WebContents* tab = chrome::GetActiveWebContents(browser());
+  tab->GetController().Reload(false);
+  content::WaitForLoadStop(tab);
+
+  urls = GetHistoryContents();
+  ASSERT_EQ(2u, urls.size());
+  ASSERT_EQ(url1, urls[0]);
+  ASSERT_EQ(url2, urls[1]);
+}
+
+// Verify that back/forward brings current page to top of history list.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, BackForwardBringPageToTop) {
+  GURL url1 = GetTestUrl();
+  GURL url2  = ui_test_utils::GetTestUrl(
+      FilePath(), FilePath(FILE_PATH_LITERAL("title3.html")));
+
+  ui_test_utils::NavigateToURL(browser(), url1);
+  ui_test_utils::NavigateToURL(browser(), url2);
+
+  content::WebContents* tab = chrome::GetActiveWebContents(browser());
+  chrome::GoBack(browser(), CURRENT_TAB);
+  content::WaitForLoadStop(tab);
+
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(2u, urls.size());
+  ASSERT_EQ(url1, urls[0]);
+  ASSERT_EQ(url2, urls[1]);
+
+  chrome::GoForward(browser(), CURRENT_TAB);
+  content::WaitForLoadStop(tab);
+  urls = GetHistoryContents();
+  ASSERT_EQ(2u, urls.size());
+  ASSERT_EQ(url2, urls[0]);
+  ASSERT_EQ(url1, urls[1]);
+}
+
+// Verify that submitting form adds target page to history list.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, SubmitFormAddsTargetPage) {
+  GURL form = ui_test_utils::GetTestUrl(
+      FilePath().AppendASCII("History"),
+      FilePath().AppendASCII("form.html"));
+  GURL target = ui_test_utils::GetTestUrl(
+      FilePath().AppendASCII("History"),
+      FilePath().AppendASCII("target.html"));
+  ui_test_utils::NavigateToURL(browser(), form);
+
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  string16 expected_title(ASCIIToUTF16("Target Page"));
+  content::TitleWatcher title_watcher(
+      chrome::GetActiveWebContents(browser()), expected_title);
+  ASSERT_TRUE(content::ExecuteJavaScript(
+      web_contents->GetRenderViewHost(),
+      L"",
+      ASCIIToWide("document.getElementById('form').submit()")));
+  EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
+
+  std::vector<GURL> urls(GetHistoryContents());
+  ASSERT_EQ(2u, urls.size());
+  ASSERT_EQ(target, urls[0]);
+  ASSERT_EQ(form, urls[1]);
+}
+
+// Verify history shortcut opens only one history tab per window.  Also, make
+// sure that existing history tab is activated.
+IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, OneHistoryTabPerWindow) {
+  GURL history_url("chrome://chrome/history/");
+
+  // Even after navigate completes, the currently-active tab title is
+  // 'Loading...' for a brief time while the history page loads.
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  string16 expected_title(ASCIIToUTF16("History"));
+  content::TitleWatcher title_watcher(web_contents, expected_title);
+  chrome::ExecuteCommand(browser(), IDC_SHOW_HISTORY);
+  EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
+
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(), GURL(chrome::kAboutBlankURL), NEW_FOREGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+  chrome::ExecuteCommand(browser(), IDC_SHOW_HISTORY);
+
+  content::WebContents* active_web_contents =
+      chrome::GetActiveWebContents(browser());
+  ASSERT_EQ(web_contents, active_web_contents);
+  ASSERT_EQ(history_url, active_web_contents->GetURL());
+
+  TabContents* second_tab = browser()->tab_strip_model()->GetTabContentsAt(1);
+  ASSERT_NE(history_url, second_tab->web_contents()->GetURL());
+}