Home | History | Annotate | Download | only in history 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <vector>
      6 
      7 #include "base/bind.h"
      8 #include "base/command_line.h"
      9 #include "base/message_loop/message_loop.h"
     10 #include "base/prefs/pref_service.h"
     11 #include "base/strings/utf_string_conversions.h"
     12 #include "chrome/app/chrome_command_ids.h"
     13 #include "chrome/browser/history/history_db_task.h"
     14 #include "chrome/browser/history/history_service.h"
     15 #include "chrome/browser/history/history_service_factory.h"
     16 #include "chrome/browser/profiles/profile.h"
     17 #include "chrome/browser/ui/browser.h"
     18 #include "chrome/browser/ui/browser_commands.h"
     19 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     20 #include "chrome/common/chrome_switches.h"
     21 #include "chrome/common/pref_names.h"
     22 #include "chrome/common/url_constants.h"
     23 #include "chrome/test/base/in_process_browser_test.h"
     24 #include "chrome/test/base/ui_test_utils.h"
     25 #include "content/public/browser/web_contents.h"
     26 #include "content/public/test/browser_test_utils.h"
     27 #include "content/public/test/test_browser_thread.h"
     28 #include "url/gurl.h"
     29 
     30 using content::BrowserThread;
     31 
     32 namespace {
     33 
     34 // Note: WaitableEvent is not used for synchronization between the main thread
     35 // and history backend thread because the history subsystem posts tasks back
     36 // to the main thread. Had we tried to Signal an event in such a task
     37 // and Wait for it on the main thread, the task would not run at all because
     38 // the main thread would be blocked on the Wait call, resulting in a deadlock.
     39 
     40 // A task to be scheduled on the history backend thread.
     41 // Notifies the main thread after all history backend thread tasks have run.
     42 class WaitForHistoryTask : public history::HistoryDBTask {
     43  public:
     44   WaitForHistoryTask() {}
     45 
     46   virtual bool RunOnDBThread(history::HistoryBackend* backend,
     47                              history::HistoryDatabase* db) OVERRIDE {
     48     return true;
     49   }
     50 
     51   virtual void DoneRunOnMainThread() OVERRIDE {
     52     base::MessageLoop::current()->Quit();
     53   }
     54 
     55  private:
     56   virtual ~WaitForHistoryTask() {}
     57 
     58   DISALLOW_COPY_AND_ASSIGN(WaitForHistoryTask);
     59 };
     60 
     61 }  // namespace
     62 
     63 class HistoryBrowserTest : public InProcessBrowserTest {
     64  protected:
     65   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     66     command_line->AppendSwitch(switches::kEnableFileCookies);
     67   }
     68 
     69   PrefService* GetPrefs() {
     70     return GetProfile()->GetPrefs();
     71   }
     72 
     73   Profile* GetProfile() {
     74     return browser()->profile();
     75   }
     76 
     77   std::vector<GURL> GetHistoryContents() {
     78     ui_test_utils::HistoryEnumerator enumerator(GetProfile());
     79     return enumerator.urls();
     80   }
     81 
     82   GURL GetTestUrl() {
     83     return ui_test_utils::GetTestUrl(
     84         base::FilePath(base::FilePath::kCurrentDirectory),
     85         base::FilePath(FILE_PATH_LITERAL("title2.html")));
     86   }
     87 
     88   void WaitForHistoryBackendToRun() {
     89     CancelableRequestConsumerTSimple<int> request_consumer;
     90     scoped_refptr<history::HistoryDBTask> task(new WaitForHistoryTask());
     91     HistoryService* history =
     92         HistoryServiceFactory::GetForProfile(GetProfile(),
     93                                              Profile::EXPLICIT_ACCESS);
     94     history->HistoryService::ScheduleDBTask(task.get(), &request_consumer);
     95     content::RunMessageLoop();
     96   }
     97 
     98   void ExpectEmptyHistory() {
     99     std::vector<GURL> urls(GetHistoryContents());
    100     EXPECT_EQ(0U, urls.size());
    101   }
    102 
    103   void LoadAndWaitForURL(const GURL& url) {
    104     base::string16 expected_title(ASCIIToUTF16("OK"));
    105     content::TitleWatcher title_watcher(
    106         browser()->tab_strip_model()->GetActiveWebContents(), expected_title);
    107     title_watcher.AlsoWaitForTitle(ASCIIToUTF16("FAIL"));
    108     ui_test_utils::NavigateToURL(browser(), url);
    109     EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
    110   }
    111 
    112   void LoadAndWaitForFile(const char* filename) {
    113     GURL url = ui_test_utils::GetTestUrl(
    114         base::FilePath().AppendASCII("History"),
    115         base::FilePath().AppendASCII(filename));
    116     LoadAndWaitForURL(url);
    117   }
    118 };
    119 
    120 // Test that the browser history is saved (default setting).
    121 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, SavingHistoryEnabled) {
    122   EXPECT_FALSE(GetPrefs()->GetBoolean(prefs::kSavingBrowserHistoryDisabled));
    123 
    124   EXPECT_TRUE(HistoryServiceFactory::GetForProfile(
    125       GetProfile(), Profile::EXPLICIT_ACCESS));
    126   EXPECT_TRUE(HistoryServiceFactory::GetForProfile(
    127       GetProfile(), Profile::IMPLICIT_ACCESS));
    128 
    129   ui_test_utils::WaitForHistoryToLoad(HistoryServiceFactory::GetForProfile(
    130       browser()->profile(), Profile::EXPLICIT_ACCESS));
    131   ExpectEmptyHistory();
    132 
    133   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    134   WaitForHistoryBackendToRun();
    135 
    136   {
    137     std::vector<GURL> urls(GetHistoryContents());
    138     ASSERT_EQ(1U, urls.size());
    139     EXPECT_EQ(GetTestUrl().spec(), urls[0].spec());
    140   }
    141 }
    142 
    143 // Test that disabling saving browser history really works.
    144 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, SavingHistoryDisabled) {
    145   GetPrefs()->SetBoolean(prefs::kSavingBrowserHistoryDisabled, true);
    146 
    147   EXPECT_TRUE(HistoryServiceFactory::GetForProfile(
    148       GetProfile(), Profile::EXPLICIT_ACCESS));
    149   EXPECT_FALSE(HistoryServiceFactory::GetForProfile(
    150       GetProfile(), Profile::IMPLICIT_ACCESS));
    151 
    152   ui_test_utils::WaitForHistoryToLoad(HistoryServiceFactory::GetForProfile(
    153       browser()->profile(), Profile::EXPLICIT_ACCESS));
    154   ExpectEmptyHistory();
    155 
    156   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    157   WaitForHistoryBackendToRun();
    158   ExpectEmptyHistory();
    159 }
    160 
    161 // Test that changing the pref takes effect immediately
    162 // when the browser is running.
    163 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, SavingHistoryEnabledThenDisabled) {
    164   EXPECT_FALSE(GetPrefs()->GetBoolean(prefs::kSavingBrowserHistoryDisabled));
    165 
    166   ui_test_utils::WaitForHistoryToLoad(HistoryServiceFactory::GetForProfile(
    167       browser()->profile(), Profile::EXPLICIT_ACCESS));
    168 
    169   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    170   WaitForHistoryBackendToRun();
    171 
    172   {
    173     std::vector<GURL> urls(GetHistoryContents());
    174     ASSERT_EQ(1U, urls.size());
    175     EXPECT_EQ(GetTestUrl().spec(), urls[0].spec());
    176   }
    177 
    178   GetPrefs()->SetBoolean(prefs::kSavingBrowserHistoryDisabled, true);
    179 
    180   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    181   WaitForHistoryBackendToRun();
    182 
    183   {
    184     // No additional entries should be present in the history.
    185     std::vector<GURL> urls(GetHistoryContents());
    186     ASSERT_EQ(1U, urls.size());
    187     EXPECT_EQ(GetTestUrl().spec(), urls[0].spec());
    188   }
    189 }
    190 
    191 // Test that changing the pref takes effect immediately
    192 // when the browser is running.
    193 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, SavingHistoryDisabledThenEnabled) {
    194   GetPrefs()->SetBoolean(prefs::kSavingBrowserHistoryDisabled, true);
    195 
    196   ui_test_utils::WaitForHistoryToLoad(HistoryServiceFactory::GetForProfile(
    197       browser()->profile(), Profile::EXPLICIT_ACCESS));
    198   ExpectEmptyHistory();
    199 
    200   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    201   WaitForHistoryBackendToRun();
    202   ExpectEmptyHistory();
    203 
    204   GetPrefs()->SetBoolean(prefs::kSavingBrowserHistoryDisabled, false);
    205 
    206   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    207   WaitForHistoryBackendToRun();
    208 
    209   {
    210     std::vector<GURL> urls(GetHistoryContents());
    211     ASSERT_EQ(1U, urls.size());
    212     EXPECT_EQ(GetTestUrl().spec(), urls[0].spec());
    213   }
    214 }
    215 
    216 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, VerifyHistoryLength1) {
    217   // Test the history length for the following page transitions.
    218   //   -open-> Page 1.
    219   LoadAndWaitForFile("history_length_test_page_1.html");
    220 }
    221 
    222 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, VerifyHistoryLength2) {
    223   // Test the history length for the following page transitions.
    224   //   -open-> Page 2 -redirect-> Page 3.
    225   LoadAndWaitForFile("history_length_test_page_2.html");
    226 }
    227 
    228 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, VerifyHistoryLength3) {
    229   // Test the history length for the following page transitions.
    230   // -open-> Page 1 -> open Page 2 -redirect Page 3. open Page 4
    231   // -navigate_backward-> Page 3 -navigate_backward->Page 1
    232   // -navigate_forward-> Page 3 -navigate_forward-> Page 4
    233   LoadAndWaitForFile("history_length_test_page_1.html");
    234   LoadAndWaitForFile("history_length_test_page_2.html");
    235   LoadAndWaitForFile("history_length_test_page_4.html");
    236 }
    237 
    238 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest,
    239                        ConsiderRedirectAfterGestureAsUserInitiated) {
    240   // Test the history length for the following page transition.
    241   //
    242   // -open-> Page 11 -slow_redirect-> Page 12.
    243   //
    244   // If redirect occurs after a user gesture, e.g., mouse click, the
    245   // redirect is more likely to be user-initiated rather than automatic.
    246   // Therefore, Page 11 should be in the history in addition to Page 12.
    247   LoadAndWaitForFile("history_length_test_page_11.html");
    248 
    249   content::SimulateMouseClick(
    250       browser()->tab_strip_model()->GetActiveWebContents(), 0,
    251       blink::WebMouseEvent::ButtonLeft);
    252   LoadAndWaitForFile("history_length_test_page_11.html");
    253 }
    254 
    255 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest,
    256                        ConsiderSlowRedirectAsUserInitiated) {
    257   // Test the history length for the following page transition.
    258   //
    259   // -open-> Page 21 -redirect-> Page 22.
    260   //
    261   // If redirect occurs more than 5 seconds later after the page is loaded,
    262   // the redirect is likely to be user-initiated.
    263   // Therefore, Page 21 should be in the history in addition to Page 22.
    264   LoadAndWaitForFile("history_length_test_page_21.html");
    265 }
    266 
    267 // http://crbug.com/22111
    268 #if defined(OS_LINUX)
    269 #define MAYBE_HistorySearchXSS DISABLED_HistorySearchXSS
    270 #else
    271 #define MAYBE_HistorySearchXSS HistorySearchXSS
    272 #endif
    273 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, MAYBE_HistorySearchXSS) {
    274   GURL url(std::string(chrome::kChromeUIHistoryURL) +
    275       "#q=%3Cimg%20src%3Dx%3Ax%20onerror%3D%22document.title%3D'XSS'%22%3E");
    276   ui_test_utils::NavigateToURL(browser(), url);
    277   // Mainly, this is to ensure we send a synchronous message to the renderer
    278   // so that we're not susceptible (less susceptible?) to a race condition.
    279   // Should a race condition ever trigger, it won't result in flakiness.
    280   int num = ui_test_utils::FindInPage(
    281       browser()->tab_strip_model()->GetActiveWebContents(),
    282       ASCIIToUTF16("<img"), true,
    283       true, NULL, NULL);
    284   EXPECT_GT(num, 0);
    285   EXPECT_EQ(ASCIIToUTF16("History"),
    286             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
    287 }
    288 
    289 // Verify that history persists after session restart.
    290 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, PRE_HistoryPersists) {
    291   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    292   std::vector<GURL> urls(GetHistoryContents());
    293   ASSERT_EQ(1u, urls.size());
    294   ASSERT_EQ(GetTestUrl(), urls[0]);
    295 }
    296 
    297 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, HistoryPersists) {
    298   std::vector<GURL> urls(GetHistoryContents());
    299   ASSERT_EQ(1u, urls.size());
    300   ASSERT_EQ(GetTestUrl(), urls[0]);
    301 }
    302 
    303 // Invalid URLs should not go in history.
    304 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, InvalidURLNoHistory) {
    305   GURL non_existant = ui_test_utils::GetTestUrl(
    306       base::FilePath().AppendASCII("History"),
    307       base::FilePath().AppendASCII("non_existant_file.html"));
    308   ui_test_utils::NavigateToURL(browser(), non_existant);
    309   ExpectEmptyHistory();
    310 }
    311 
    312 // New tab page should not show up in history.
    313 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, NewTabNoHistory) {
    314   ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUINewTabURL));
    315   ExpectEmptyHistory();
    316 }
    317 
    318 // Incognito browsing should not show up in history.
    319 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, IncognitoNoHistory) {
    320   ui_test_utils::NavigateToURL(CreateIncognitoBrowser(), GetTestUrl());
    321   ExpectEmptyHistory();
    322 }
    323 
    324 // Multiple navigations to the same url should have a single history.
    325 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, NavigateMultiTimes) {
    326   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    327   ui_test_utils::NavigateToURL(browser(), GetTestUrl());
    328   std::vector<GURL> urls(GetHistoryContents());
    329   ASSERT_EQ(1u, urls.size());
    330   ASSERT_EQ(GetTestUrl(), urls[0]);
    331 }
    332 
    333 // Verify history with multiple windows and tabs.
    334 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, MultiTabsWindowsHistory) {
    335   GURL url1 = GetTestUrl();
    336   GURL url2  = ui_test_utils::GetTestUrl(
    337       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("title1.html")));
    338   GURL url3  = ui_test_utils::GetTestUrl(
    339       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("title3.html")));
    340   GURL url4  = ui_test_utils::GetTestUrl(
    341       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("simple.html")));
    342 
    343   ui_test_utils::NavigateToURL(browser(), url1);
    344   Browser* browser2 = CreateBrowser(browser()->profile());
    345   ui_test_utils::NavigateToURL(browser2, url2);
    346   ui_test_utils::NavigateToURLWithDisposition(
    347       browser2, url3, NEW_FOREGROUND_TAB,
    348       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
    349   ui_test_utils::NavigateToURLWithDisposition(
    350       browser2, url4, NEW_FOREGROUND_TAB,
    351       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
    352 
    353   std::vector<GURL> urls(GetHistoryContents());
    354   ASSERT_EQ(4u, urls.size());
    355   ASSERT_EQ(url4, urls[0]);
    356   ASSERT_EQ(url3, urls[1]);
    357   ASSERT_EQ(url2, urls[2]);
    358   ASSERT_EQ(url1, urls[3]);
    359 }
    360 
    361 // Downloaded URLs should not show up in history.
    362 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, DownloadNoHistory) {
    363   GURL download_url = ui_test_utils::GetTestUrl(
    364       base::FilePath().AppendASCII("downloads"),
    365       base::FilePath().AppendASCII("a_zip_file.zip"));
    366   ui_test_utils::DownloadURL(browser(), download_url);
    367   ExpectEmptyHistory();
    368 }
    369 
    370 // HTTP meta-refresh redirects should have separate history entries.
    371 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, RedirectHistory) {
    372   GURL redirector = ui_test_utils::GetTestUrl(
    373       base::FilePath().AppendASCII("History"),
    374       base::FilePath().AppendASCII("redirector.html"));
    375   GURL landing_url = ui_test_utils::GetTestUrl(
    376       base::FilePath().AppendASCII("History"),
    377       base::FilePath().AppendASCII("landing.html"));
    378   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
    379       browser(), redirector, 2);
    380   ASSERT_EQ(landing_url,
    381             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
    382   std::vector<GURL> urls(GetHistoryContents());
    383   ASSERT_EQ(2u, urls.size());
    384   ASSERT_EQ(landing_url, urls[0]);
    385   ASSERT_EQ(redirector, urls[1]);
    386 }
    387 
    388 // Verify that navigation brings current page to top of history list.
    389 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, NavigateBringPageToTop) {
    390   GURL url1 = GetTestUrl();
    391   GURL url2  = ui_test_utils::GetTestUrl(
    392       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("title3.html")));
    393 
    394   ui_test_utils::NavigateToURL(browser(), url1);
    395   ui_test_utils::NavigateToURL(browser(), url2);
    396 
    397   std::vector<GURL> urls(GetHistoryContents());
    398   ASSERT_EQ(2u, urls.size());
    399   ASSERT_EQ(url2, urls[0]);
    400   ASSERT_EQ(url1, urls[1]);
    401 }
    402 
    403 // Verify that reloading a page brings it to top of history list.
    404 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, ReloadBringPageToTop) {
    405   GURL url1 = GetTestUrl();
    406   GURL url2  = ui_test_utils::GetTestUrl(
    407       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("title3.html")));
    408 
    409   ui_test_utils::NavigateToURL(browser(), url1);
    410   ui_test_utils::NavigateToURLWithDisposition(
    411       browser(), url2, NEW_BACKGROUND_TAB,
    412       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
    413 
    414   std::vector<GURL> urls(GetHistoryContents());
    415   ASSERT_EQ(2u, urls.size());
    416   ASSERT_EQ(url2, urls[0]);
    417   ASSERT_EQ(url1, urls[1]);
    418 
    419   content::WebContents* tab =
    420       browser()->tab_strip_model()->GetActiveWebContents();
    421   tab->GetController().Reload(false);
    422   content::WaitForLoadStop(tab);
    423 
    424   urls = GetHistoryContents();
    425   ASSERT_EQ(2u, urls.size());
    426   ASSERT_EQ(url1, urls[0]);
    427   ASSERT_EQ(url2, urls[1]);
    428 }
    429 
    430 // Verify that back/forward brings current page to top of history list.
    431 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, BackForwardBringPageToTop) {
    432   GURL url1 = GetTestUrl();
    433   GURL url2  = ui_test_utils::GetTestUrl(
    434       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("title3.html")));
    435 
    436   ui_test_utils::NavigateToURL(browser(), url1);
    437   ui_test_utils::NavigateToURL(browser(), url2);
    438 
    439   content::WebContents* tab =
    440       browser()->tab_strip_model()->GetActiveWebContents();
    441   chrome::GoBack(browser(), CURRENT_TAB);
    442   content::WaitForLoadStop(tab);
    443 
    444   std::vector<GURL> urls(GetHistoryContents());
    445   ASSERT_EQ(2u, urls.size());
    446   ASSERT_EQ(url1, urls[0]);
    447   ASSERT_EQ(url2, urls[1]);
    448 
    449   chrome::GoForward(browser(), CURRENT_TAB);
    450   content::WaitForLoadStop(tab);
    451   urls = GetHistoryContents();
    452   ASSERT_EQ(2u, urls.size());
    453   ASSERT_EQ(url2, urls[0]);
    454   ASSERT_EQ(url1, urls[1]);
    455 }
    456 
    457 // Verify that submitting form adds target page to history list.
    458 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, SubmitFormAddsTargetPage) {
    459   GURL form = ui_test_utils::GetTestUrl(
    460       base::FilePath().AppendASCII("History"),
    461       base::FilePath().AppendASCII("form.html"));
    462   GURL target = ui_test_utils::GetTestUrl(
    463       base::FilePath().AppendASCII("History"),
    464       base::FilePath().AppendASCII("target.html"));
    465   ui_test_utils::NavigateToURL(browser(), form);
    466 
    467   content::WebContents* web_contents =
    468       browser()->tab_strip_model()->GetActiveWebContents();
    469   base::string16 expected_title(ASCIIToUTF16("Target Page"));
    470   content::TitleWatcher title_watcher(
    471       browser()->tab_strip_model()->GetActiveWebContents(), expected_title);
    472   ASSERT_TRUE(content::ExecuteScript(
    473       web_contents, "document.getElementById('form').submit()"));
    474   EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
    475 
    476   std::vector<GURL> urls(GetHistoryContents());
    477   ASSERT_EQ(2u, urls.size());
    478   ASSERT_EQ(target, urls[0]);
    479   ASSERT_EQ(form, urls[1]);
    480 }
    481 
    482 // Verify history shortcut opens only one history tab per window.  Also, make
    483 // sure that existing history tab is activated.
    484 IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, OneHistoryTabPerWindow) {
    485   GURL history_url(chrome::kChromeUIHistoryURL);
    486 
    487   // Even after navigate completes, the currently-active tab title is
    488   // 'Loading...' for a brief time while the history page loads.
    489   content::WebContents* web_contents =
    490       browser()->tab_strip_model()->GetActiveWebContents();
    491   base::string16 expected_title(ASCIIToUTF16("History"));
    492   content::TitleWatcher title_watcher(web_contents, expected_title);
    493   chrome::ExecuteCommand(browser(), IDC_SHOW_HISTORY);
    494   EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
    495 
    496   ui_test_utils::NavigateToURLWithDisposition(
    497       browser(), GURL(content::kAboutBlankURL), NEW_FOREGROUND_TAB,
    498       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
    499   chrome::ExecuteCommand(browser(), IDC_SHOW_HISTORY);
    500 
    501   content::WebContents* active_web_contents =
    502       browser()->tab_strip_model()->GetActiveWebContents();
    503   ASSERT_EQ(web_contents, active_web_contents);
    504   ASSERT_EQ(history_url, active_web_contents->GetURL());
    505 
    506   content::WebContents* second_tab =
    507       browser()->tab_strip_model()->GetWebContentsAt(1);
    508   ASSERT_NE(history_url, second_tab->GetURL());
    509 }
    510