Implements tests for testing browser's overall key events handling behavior....

chrome/browser/browser_focus_uitest.cc

 // Copyright (c) 2009 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 "build/build_config.h"
 
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/browser.h"
@@ skipping 40 matching lines @@
 const wchar_t kTypicalPage[] = L"files/focus/typical_page.html";
 const char kTypicalPageName[] = "typical_page.html";
 
 class BrowserFocusTest : public InProcessBrowserTest {
  public:
   BrowserFocusTest() {
     set_show_window(true);
     EnableDOMAutomation();
   }
 
-  void CheckViewHasFocus(ViewID vid) {
-    BrowserWindow* browser_window = browser()->window();
-    ASSERT_TRUE(browser_window);
-    gfx::NativeWindow window = browser_window->GetNativeHandle();
-    ASSERT_TRUE(window);
-#if defined(OS_WIN)
-    views::FocusManager* focus_manager =
-        views::FocusManager::GetFocusManagerForNativeView(window);
-    ASSERT_TRUE(focus_manager);
-    EXPECT_EQ(vid, focus_manager->GetFocusedView()->GetID()) <<
-        "For view id " << vid;
-#elif defined(OS_LINUX)
-    GtkWidget* widget = ViewIDUtil::GetWidget(GTK_WIDGET(window), vid);
-    ASSERT_TRUE(widget);
-    EXPECT_TRUE(WidgetInFocusChain(GTK_WIDGET(window), widget)) <<
-        "For view id " << vid;
-#else
-    NOTIMPLEMENTED();
-#endif
+  bool IsViewFocused(ViewID vid) {
+    return ui_test_utils::IsViewFocused(browser(), vid);
   }
 
   void ClickOnView(ViewID vid) {
-    BrowserWindow* browser_window = browser()->window();
-    ASSERT_TRUE(browser_window);
-#if defined(TOOLKIT_VIEWS)
-    views::View* view =
-        reinterpret_cast<BrowserView*>(browser_window)->GetViewByID(vid);
-#elif defined(OS_LINUX)
-    gfx::NativeWindow window = browser_window->GetNativeHandle();
-    ASSERT_TRUE(window);
-    GtkWidget* view = ViewIDUtil::GetWidget(GTK_WIDGET(window), vid);
-#endif
-    ASSERT_TRUE(view);
-    ui_controls::MoveMouseToCenterAndPress(
-        view,
-        ui_controls::LEFT,
-        ui_controls::DOWN | ui_controls::UP,
-        new MessageLoop::QuitTask());
-    ui_test_utils::RunMessageLoop();
+    ui_test_utils::ClickOnView(browser(), vid);
   }
 
   static void HideNativeWindow(gfx::NativeWindow window) {
 #if defined(OS_WIN)
     // TODO(jcampan): retrieve the WidgetWin and show/hide on it instead of
     // using Windows API.
     ::ShowWindow(window, SW_HIDE);
 #elif defined(OS_LINUX)
     gtk_widget_hide(GTK_WIDGET(window));
 #else
     NOTIMPLEMENTED();
 #endif
   }
 
   static void ShowNativeWindow(gfx::NativeWindow window) {
 #if defined(OS_WIN)
     // TODO(jcampan): retrieve the WidgetWin and show/hide on it instead of
     // using Windows API.
     ::ShowWindow(window, SW_SHOW);
 #elif defined(OS_LINUX)
     gtk_widget_hide(GTK_WIDGET(window));
 #else
     NOTIMPLEMENTED();
 #endif
   }
-
- private:
-#if defined(OS_LINUX)
-  // Check if the focused widget for |root| is |target| or a child of |target|.
-  static bool WidgetInFocusChain(GtkWidget* root, GtkWidget* target) {
-    GtkWidget* iter = root;
-
-    while (iter) {
-      if (iter == target)
-        return true;
-
-      if (!GTK_IS_CONTAINER(iter))
-        return false;
-
-      iter = GTK_CONTAINER(iter)->focus_child;
-    }
-
-    return false;
-  }
-#endif
 };
 
 class TestInterstitialPage : public InterstitialPage {
  public:
   TestInterstitialPage(TabContents* tab, bool new_navigation, const GURL& url)
       : InterstitialPage(tab, new_navigation, url),
         waiting_for_dom_response_(false),
         waiting_for_focus_change_(false) {
     FilePath file_path;
     bool r = PathService::Get(chrome::DIR_TEST_DATA, &file_path);
@@ skipping 66 matching lines @@
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, ClickingMovesFocus) {
 #if defined(OS_LINUX)
   // It seems we have to wait a little bit for the widgets to spin up before
   // we can start clicking on them.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           new MessageLoop::QuitTask(),
                                           kActionDelayMs);
   ui_test_utils::RunMessageLoop();
 #endif
 
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   ClickOnView(VIEW_ID_TAB_CONTAINER);
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   ClickOnView(VIEW_ID_LOCATION_BAR);
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, BrowsersRememberFocus) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our test page.
   GURL url = server->TestServerPageW(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   gfx::NativeWindow window = browser()->window()->GetNativeHandle();
 
   // The focus should be on the Tab contents.
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
   // Now hide the window, show it again, the focus should not have changed.
   HideNativeWindow(window);
   ShowNativeWindow(window);
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   browser()->FocusLocationBar();
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
   // Hide the window, show it again, the focus should not have changed.
   HideNativeWindow(window);
   ShowNativeWindow(window);
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   // The rest of this test does not make sense on Linux because the behavior
   // of Activate() is not well defined and can vary by window manager.
 #if defined(OS_WIN)
   // Open a new browser window.
   Browser* browser2 = Browser::Create(browser()->profile());
   ASSERT_TRUE(browser2);
   browser2->tabstrip_model()->delegate()->AddBlankTab(true);
   browser2->window()->Show();
   ui_test_utils::NavigateToURL(browser2, url);
 
   HWND hwnd2 = reinterpret_cast<HWND>(browser2->window()->GetNativeHandle());
   BrowserView* browser_view2 =
       BrowserView::GetBrowserViewForNativeWindow(hwnd2);
   ASSERT_TRUE(browser_view2);
   views::FocusManager* focus_manager2 =
       views::FocusManager::GetFocusManagerForNativeView(hwnd2);
   ASSERT_TRUE(focus_manager2);
   EXPECT_EQ(browser_view2->GetTabContentsContainerView(),
             focus_manager2->GetFocusedView());
 
   // Switch to the 1st browser window, focus should still be on the location
   // bar and the second browser should have nothing focused.
   browser()->window()->Activate();
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
   EXPECT_EQ(NULL, focus_manager2->GetFocusedView());
 
   // Switch back to the second browser, focus should still be on the page.
   browser2->window()->Activate();
   EXPECT_EQ(NULL,
             views::FocusManager::GetFocusManagerForNativeView(
                 browser()->window()->GetNativeHandle())->GetFocusedView());
   EXPECT_EQ(browser_view2->GetTabContentsContainerView(),
             focus_manager2->GetFocusedView());
 
@@ skipping 36 matching lines @@
       }
     }
 
     // Now come back to the tab and check the right view is focused.
     for (int j = 0; j < 5; j++) {
       // Activate the tab.
       browser()->SelectTabContentsAt(j, true);
 
       ViewID vid = kFocusPage[i][j] ? VIEW_ID_TAB_CONTAINER_FOCUS_VIEW :
                                       VIEW_ID_LOCATION_BAR;
-      CheckViewHasFocus(vid);
+      ASSERT_TRUE(IsViewFocused(vid));
     }
   }
 }
 
 // Tabs remember focus with find-in-page box.
 // TODO(jcampan): http://crbug.com/23683 Disabled because it fails on Linux.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, DISABLED_TabsRememberFocusFindInPage) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our test page.
   GURL url = server->TestServerPageW(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   browser()->Find();
   ui_test_utils::FindInPage(browser()->GetSelectedTabContents(),
                             ASCIIToUTF16("a"), true, false, NULL);
-  CheckViewHasFocus(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 
   // Focus the location bar.
   browser()->FocusLocationBar();
 
   // Create a 2nd tab.
   browser()->AddTabWithURL(url, GURL(), PageTransition::TYPED, true, -1,
                            false, NULL);
 
   // Focus should be on the recently opened tab page.
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Select 1st tab, focus should still be on the location-bar.
   // (bug http://crbug.com/23296)
   browser()->SelectTabContentsAt(0, true);
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   // Now open the find box again, switch to another tab and come back, the focus
   // should return to the find box.
   browser()->Find();
-  CheckViewHasFocus(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
   browser()->SelectTabContentsAt(1, true);
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
   browser()->SelectTabContentsAt(0, true);
-  CheckViewHasFocus(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 }
 
 // Background window does not steal focus.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, BackgroundBrowserDontStealFocus) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our test page.
   GURL url = server->TestServerPageW(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
@@ skipping 45 matching lines @@
   // Open the page that steals focus.
   GURL url = server->TestServerPageW(kStealFocusPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   browser()->FocusLocationBar();
 
   // Wait for the page to steal focus.
   PlatformThread::Sleep(2000);
 
   // Make sure the location bar is still focused.
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 }
 
 // Focus traversal on a regular page.
 // Note that this test relies on a notification from the renderer that the
 // focus has changed in the page.  The notification in the renderer may change
 // at which point this test would fail (see comment in
 // RenderWidget::didFocus()).
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FocusTraversal) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our test page.
   GURL url = server->TestServerPageW(kTypicalPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   browser()->FocusLocationBar();
 
   const char* kExpElementIDs[] = {
     "",  // Initially no element in the page should be focused
          // (the location bar is focused).
     "textEdit", "searchButton", "luckyButton", "googleLink", "gmailLink",
     "gmapLink"
   };
 
   gfx::NativeWindow window = browser()->window()->GetNativeHandle();
 
   // Test forward focus traversal.
   for (int i = 0; i < 3; ++i) {
     // Location bar should be focused.
-    CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+    ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
     // Now let's press tab to move the focus.
     for (size_t j = 0; j < arraysize(kExpElementIDs); ++j) {
       // Let's make sure the focus is on the expected element in the page.
       std::string actual;
       ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractString(
           browser()->GetSelectedTabContents()->render_view_host(),
           L"",
           L"window.domAutomationController.send(getFocusedElement());",
           &actual));
@@ skipping 13 matching lines @@
 
     // At this point the renderer has sent us a message asking to advance the
     // focus (as the end of the focus loop was reached in the renderer).
     // We need to run the message loop to process it.
     MessageLoop::current()->RunAllPending();
   }
 
   // Now let's try reverse focus traversal.
   for (int i = 0; i < 3; ++i) {
     // Location bar should be focused.
-    CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+    ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
     // Now let's press shift-tab to move the focus in reverse.
     for (size_t j = 0; j < 7; ++j) {
       ASSERT_TRUE(ui_controls::SendKeyPress(window, base::VKEY_TAB,
                                             false, true, false));
 
       if (j < arraysize(kExpElementIDs) - 1) {
         ui_test_utils::WaitForFocusChange(browser()->GetSelectedTabContents()->
             render_view_host());
       } else {
@@ skipping 20 matching lines @@
 
 // Focus traversal while an interstitial is showing.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, MAYBE_FocusTraversalOnInterstitial) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our test page.
   GURL url = server->TestServerPageW(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Focus should be on the page.
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Let's show an interstitial.
   TestInterstitialPage* interstitial_page =
       new TestInterstitialPage(browser()->GetSelectedTabContents(),
                                true, GURL("http://interstitial.com"));
   interstitial_page->Show();
   // Give some time for the interstitial to show.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           new MessageLoop::QuitTask(),
                                           1000);
   ui_test_utils::RunMessageLoop();
 
   browser()->FocusLocationBar();
 
   const char* kExpElementIDs[] = {
     "",  // Initially no element in the page should be focused
          // (the location bar is focused).
     "textEdit", "searchButton", "luckyButton", "googleLink", "gmailLink",
     "gmapLink"
   };
 
   gfx::NativeWindow window = browser()->window()->GetNativeHandle();
 
   // Test forward focus traversal.
   for (int i = 0; i < 2; ++i) {
     // Location bar should be focused.
-    CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+    ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
     // Now let's press tab to move the focus.
     for (size_t j = 0; j < 7; ++j) {
       // Let's make sure the focus is on the expected element in the page.
       std::string actual = interstitial_page->GetFocusedElement();
       ASSERT_STREQ(kExpElementIDs[j], actual.c_str());
 
       ASSERT_TRUE(ui_controls::SendKeyPress(window, base::VKEY_TAB,
                                             false, false, false));
 
       if (j < arraysize(kExpElementIDs) - 1) {
         interstitial_page->WaitForFocusChange();
       } else {
         // On the last tab key press, the focus returns to the browser.
         ui_test_utils::WaitForFocusInBrowser(browser());
       }
     }
 
     // At this point the renderer has sent us a message asking to advance the
     // focus (as the end of the focus loop was reached in the renderer).
     // We need to run the message loop to process it.
     MessageLoop::current()->RunAllPending();
   }
 
   // Now let's try reverse focus traversal.
   for (int i = 0; i < 2; ++i) {
     // Location bar should be focused.
-    CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+    ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
     // Now let's press shift-tab to move the focus in reverse.
     for (size_t j = 0; j < 7; ++j) {
       ASSERT_TRUE(ui_controls::SendKeyPress(window, base::VKEY_TAB,
                                             false, true, false));
 
       if (j < arraysize(kExpElementIDs) - 1) {
         interstitial_page->WaitForFocusChange();
       } else {
         // On the last tab key press, the focus returns to the browser.
@@ skipping 14 matching lines @@
 
 // Focus stays on page with interstitials.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, InterstitialFocus) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our test page.
   GURL url = server->TestServerPageW(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Page should have focus.
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
   EXPECT_TRUE(browser()->GetSelectedTabContents()->render_view_host()->view()->
       HasFocus());
 
   // Let's show an interstitial.
   TestInterstitialPage* interstitial_page =
       new TestInterstitialPage(browser()->GetSelectedTabContents(),
                                true, GURL("http://interstitial.com"));
   interstitial_page->Show();
   // Give some time for the interstitial to show.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           new MessageLoop::QuitTask(),
                                           1000);
   ui_test_utils::RunMessageLoop();
 
   // The interstitial should have focus now.
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
   EXPECT_TRUE(interstitial_page->HasFocus());
 
   // Hide the interstitial.
   interstitial_page->DontProceed();
 
   // Focus should be back on the original page.
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 }
 
 // Make sure Find box can request focus, even when it is already open.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FindFocusTest) {
   HTTPTestServer* server = StartHTTPServer();
 
   // Open some page (any page that doesn't steal focus).
   GURL url = server->TestServerPageW(kTypicalPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   gfx::NativeWindow window = browser()->window()->GetNativeHandle();
 
   // Press Ctrl+F, which will make the Find box open and request focus.
   ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, true,
                                           false, false,
                                           new MessageLoop::QuitTask());
   ui_test_utils::RunMessageLoop();
 
   // Ideally, we wouldn't sleep here and instead would intercept the
   // RenderViewHostDelegate::HandleKeyboardEvent() callback.  To do that, we
   // could create a RenderViewHostDelegate wrapper and hook-it up by either:
   // - creating a factory used to create the delegate
   // - making the test a private and overwriting the delegate member directly.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, new MessageLoop::QuitTask(), kActionDelayMs);
   ui_test_utils::RunMessageLoop();
 
-  CheckViewHasFocus(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 
   browser()->FocusLocationBar();
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   // Now press Ctrl+F again and focus should move to the Find box.
   ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, true,
                                           false, false,
                                           new MessageLoop::QuitTask());
   ui_test_utils::RunMessageLoop();
-  CheckViewHasFocus(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 
   // Set focus to the page.
   ClickOnView(VIEW_ID_TAB_CONTAINER);
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Now press Ctrl+F again and focus should move to the Find box.
   ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, true, false,
                                           false, new MessageLoop::QuitTask());
   ui_test_utils::RunMessageLoop();
 
   // See remark above on why we wait.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, new MessageLoop::QuitTask(), kActionDelayMs);
   ui_test_utils::RunMessageLoop();
-  CheckViewHasFocus(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 }
 
 // Makes sure the focus is in the right location when opening the different
 // types of tabs.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, TabInitialFocus) {
   // Open the history tab, focus should be on the tab contents.
   browser()->ShowHistoryTab();
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Open the new tab, focus should be on the location bar.
   browser()->NewTab();
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   // Open the download tab, focus should be on the tab contents.
   browser()->ShowDownloadsTab();
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Open about:blank, focus should be on the location bar.
   browser()->AddTabWithURL(GURL("about:blank"), GURL(), PageTransition::LINK,
                            true, -1, false, NULL);
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 }
 
 // Tests that focus goes where expected when using reload.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FocusOnReload) {
   HTTPTestServer* server = StartHTTPServer();
 
   // Open the new tab, reload.
   browser()->NewTab();
   browser()->Reload();
   ASSERT_TRUE(ui_test_utils::WaitForNavigationInCurrentTab(browser()));
   // Focus should stay on the location bar.
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   // Open a regular page, focus the location bar, reload.
   ui_test_utils::NavigateToURL(browser(), server->TestServerPageW(kSimplePage));
   browser()->FocusLocationBar();
-  CheckViewHasFocus(VIEW_ID_LOCATION_BAR);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
   browser()->Reload();
   ASSERT_TRUE(ui_test_utils::WaitForNavigationInCurrentTab(browser()));
   // Focus should now be on the tab contents.
   browser()->ShowDownloadsTab();
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 }
 
 // Tests that focus goes where expected when using reload on a crashed tab.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FocusOnReloadCrashedTab) {
   HTTPTestServer* server = StartHTTPServer();
 
   // Open a regular page, crash, reload.
   ui_test_utils::NavigateToURL(browser(), server->TestServerPageW(kSimplePage));
   ui_test_utils::CrashTab(browser()->GetSelectedTabContents());
   browser()->Reload();
   ASSERT_TRUE(ui_test_utils::WaitForNavigationInCurrentTab(browser()));
   // Focus should now be on the tab contents.
   browser()->ShowDownloadsTab();
-  CheckViewHasFocus(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+  ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 }