Allow users to close the find session and activate the current link via ctrl-...

chrome/browser/find_bar_host_browsertest.cc

 // Copyright (c) 2010 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/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/find_bar_controller.h"
 #include "chrome/browser/find_notification_details.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/browser/views/find_bar_host.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
+
+#if defined(TOOLKIT_VIEWS)
 #include "views/focus/focus_manager.h"
+#endif
+
+// http://crbug.com/37809
+#if defined(OS_LINUX) && defined(TOOLKIT_GTK)
+#define FindDisappearOnNavigate DISABLED_FindDisappearOnNavigate
+#define FindDisappearOnNewTabAndHistory \
+    DISABLED_FindDisappearOnNewTabAndHistory
+#define FindMovesWhenObscuring DISABLED_FindMovesWhenObscuring
+#endif
 
 const std::wstring kSimplePage = L"404_is_enough_for_us.html";
 const std::wstring kFramePage = L"files/find_in_page/frames.html";
 const std::wstring kFrameData = L"files/find_in_page/framedata_general.html";
 const std::wstring kUserSelectPage = L"files/find_in_page/user-select.html";
 const std::wstring kCrashPage = L"files/find_in_page/crash_1341577.html";
 const std::wstring kTooFewMatchesPage = L"files/find_in_page/bug_1155639.html";
 const std::wstring kEndState = L"files/find_in_page/end_state.html";
 const std::wstring kPrematureEnd = L"files/find_in_page/premature_end.html";
 const std::wstring kMoveIfOver = L"files/find_in_page/move_if_obscuring.html";
 const std::wstring kBitstackCrash = L"files/find_in_page/crash_14491.html";
 const std::wstring kSelectChangesOrdinal =
     L"files/find_in_page/select_changes_ordinal.html";
 const std::wstring kSimple = L"files/find_in_page/simple.html";
+const std::wstring kLinkPage = L"files/find_in_page/link.html";
 
 const bool kBack = false;
 const bool kFwd = true;
 
 const bool kIgnoreCase = false;
 const bool kCaseSensitive = true;
 
 const int kMoveIterations = 30;
 
 class FindInPageControllerTest : public InProcessBrowserTest {
  public:
   FindInPageControllerTest() {
     EnableDOMAutomation();
   }
 
  protected:
   bool GetFindBarWindowInfo(gfx::Point* position, bool* fully_visible) {
     FindBarTesting* find_bar =
         browser()->GetFindBarController()->find_bar()->GetFindBarTesting();
     return find_bar->GetFindBarWindowInfo(position, fully_visible);
   }
 };
 
-// Platform independent FindInPage that takes |const wchat_t*|
+// Platform independent FindInPage that takes |const wchar_t*|
 // as an input.
 int FindInPageWchar(TabContents* tab,
                     const wchar_t* search_str,
                     bool forward,
                     bool case_sensitive,
                     int* ordinal) {
   return ui_test_utils::FindInPage(
       tab, WideToUTF16(std::wstring(search_str)),
       forward, case_sensitive, ordinal);
 }
@@ skipping 104 matching lines @@
   // Verify that nothing has focus.
   ASSERT_STREQ("{nothing focused}", FocusedOnPage(tab_contents).c_str());
 
   // Search for a text that exists within a link on the page.
   int ordinal = 0;
   EXPECT_EQ(1, FindInPageWchar(tab_contents, L"nk",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 
   // End the find session, which should set focus to the link.
-  tab_contents->StopFinding(false);
+  tab_contents->StopFinding(FindBarController::kKeepSelection);
 
   // Verify that the link is focused.
   EXPECT_STREQ("link1", FocusedOnPage(tab_contents).c_str());
 
   // Search for a text that exists within a link on the page.
   EXPECT_EQ(1, FindInPageWchar(tab_contents, L"Google",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 
   // Move the selection to link 1, after searching.
   std::string result;
   ui_test_utils::ExecuteJavaScriptAndExtractString(
       tab_contents->render_view_host(),
       L"",
       L"window.domAutomationController.send(selectLink1());",
       &result);
 
   // End the find session.
-  tab_contents->StopFinding(false);
+  tab_contents->StopFinding(FindBarController::kKeepSelection);
 
   // Verify that link2 is not focused.
   EXPECT_STREQ("", FocusedOnPage(tab_contents).c_str());
 }
 
 // This test loads a single-frame page and makes sure the ordinal returned makes
 // sense as we FindNext over all the items.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPageOrdinal) {
   HTTPTestServer* server = StartHTTPServer();
 
@@ skipping 60 matching lines @@
       &result);
 
   // Do a find-next after the selection.  This should move forward
   // from there to the 3rd instance of 'google'.
   EXPECT_EQ(4, FindInPageWchar(tab,
                                L"google",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(3, ordinal);
 
   // End the find session.
-  tab_contents->StopFinding(false);
+  tab_contents->StopFinding(FindBarController::kKeepSelection);
 }
 
 // This test loads a page with frames and makes sure the ordinal returned makes
 // sense.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPageMultiFramesOrdinal) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our page.
   GURL url = server->TestServerPageW(kFramePage);
   ui_test_utils::NavigateToURL(browser(), url);
@@ skipping 187 matching lines @@
 #define FindDisappearOnNavigate DISABLED_FindDisappearOnNavigate
 #endif
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindDisappearOnNavigate) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our special focus tracking page.
   GURL url = server->TestServerPageW(kSimplePage);
   GURL url2 = server->TestServerPageW(kFramePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
+#if defined(TOOLKIT_VIEWS)
   // Open the Find window with animations disabled.
   DropdownBarHost::disable_animations_during_testing_ = true;
+#endif
   browser()->ShowFindBar();
 
   gfx::Point position;
   bool fully_visible = false;
 
   // Make sure it is open.
   EXPECT_TRUE(GetFindBarWindowInfo(&position, &fully_visible));
   EXPECT_TRUE(fully_visible);
 
   // Reload the tab and make sure Find window doesn't go away.
@@ skipping 12 matching lines @@
 // Make sure Find box disappears when History/Downloads page is opened, and
 // when a New Tab is opened.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest,
                        FindDisappearOnNewTabAndHistory) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to our special focus tracking page.
   GURL url = server->TestServerPageW(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
+#if defined(TOOLKIT_VIEWS)
   // Open the Find window with animations disabled.
   DropdownBarHost::disable_animations_during_testing_ = true;
+#endif
   browser()->ShowFindBar();
 
   gfx::Point position;
   bool fully_visible = false;
 
   // Make sure it is open.
   EXPECT_TRUE(GetFindBarWindowInfo(&position, &fully_visible));
   EXPECT_TRUE(fully_visible);
 
   // Open another tab (tab B).
@@ skipping 18 matching lines @@
   EXPECT_FALSE(fully_visible);
 }
 
 // Make sure Find box moves out of the way if it is obscuring the active match.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindMovesWhenObscuring) {
   HTTPTestServer* server = StartHTTPServer();
 
   GURL url = server->TestServerPageW(kMoveIfOver);
   ui_test_utils::NavigateToURL(browser(), url);
 
+#if defined(TOOLKIT_VIEWS)
   // Open the Find window with animations disabled.
   DropdownBarHost::disable_animations_during_testing_ = true;
+#endif
   browser()->ShowFindBar();
 
   gfx::Point start_position;
   gfx::Point position;
   bool fully_visible = false;
 
   // Make sure it is open.
   EXPECT_TRUE(GetFindBarWindowInfo(&start_position, &fully_visible));
   EXPECT_TRUE(fully_visible);
 
@@ skipping 58 matching lines @@
   browser()->NewTab();
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Simulate what happens when you press F3 for FindNext. We should get a
   // response here (a hang means search was aborted).
   EXPECT_EQ(0, ui_test_utils::FindInPage(tab, string16(),
                                          kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(0, ordinal);
 }
 
+#if defined(TOOLKIT_VIEWS)
 // Make sure Find box grabs the Esc accelerator and restores it again.
 #if defined(OS_LINUX)
 // TODO(oshima): On Gtk/Linux, a focus out event is asynchronous and
 // hiding a find bar does not immediately update the target
 // accelerator. The last condition fails in most cases due to this
 // behavior. See http://crbug.com/26870.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest,
                        DISABLED_AcceleratorRestoring) {
 #else
   IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, AcceleratorRestoring) {
@@ skipping 21 matching lines @@
 
   views::FocusManager* focus_manager =
       views::FocusManager::GetFocusManagerForNativeView(browser_view);
 
   // See where Escape is registered.
   views::Accelerator escape(base::VKEY_ESCAPE, false, false, false);
   views::AcceleratorTarget* old_target =
       focus_manager->GetCurrentTargetForAccelerator(escape);
   EXPECT_TRUE(old_target != NULL);
 
+#if defined(TOOLKIT_VIEWS)
   // Open the Find window with animations disabled.
   DropdownBarHost::disable_animations_during_testing_ = true;
+#endif
   browser()->ShowFindBar();
 
   // Our Find bar should be the new target.
   views::AcceleratorTarget* new_target =
       focus_manager->GetCurrentTargetForAccelerator(escape);
 
   EXPECT_TRUE(new_target != NULL);
   EXPECT_NE(new_target, old_target);
 
   // Close the Find box.
-  browser()->GetFindBarController()->EndFindSession();
+  browser()->GetFindBarController()->EndFindSession(
+      FindBarController::kKeepSelection);
 
   // The accelerator for Escape should be back to what it was before.
   EXPECT_EQ(old_target,
             focus_manager->GetCurrentTargetForAccelerator(escape));
 }
+#endif  // TOOLKIT_VIEWS
 
 // Make sure Find box does not become UI-inactive when no text is in the box as
 // we switch to a tab contents with an empty find string. See issue 13570.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, StayActive) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to any page.
   GURL url = server->TestServerPageW(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
+#if defined(TOOLKIT_VIEWS)
   // Open the Find window with animations disabled.
   DropdownBarHost::disable_animations_during_testing_ = true;
+#endif
   browser()->ShowFindBar();
 
   // Simulate a user clearing the search string. Ideally, we should be
   // simulating keypresses here for searching for something and pressing
   // backspace, but that's been proven flaky in the past, so we go straight to
   // tab_contents.
   TabContents* tab_contents = browser()->GetSelectedTabContents();
   // Stop the (non-existing) find operation, and clear the selection (which
   // signals the UI is still active).
-  tab_contents->StopFinding(true);
+  tab_contents->StopFinding(FindBarController::kClearSelection);
   // Make sure the Find UI flag hasn't been cleared, it must be so that the UI
   // still responds to browser window resizing.
   ASSERT_TRUE(tab_contents->find_ui_active());
 }
 
 // Make sure F3 works after you FindNext a couple of times and end the Find
 // session. See issue http://crbug.com/28306.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, RestartSearchFromF3) {
   HTTPTestServer* server = StartHTTPServer();
 
   // First we navigate to a simple page.
   GURL url = server->TestServerPageW(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for 'page'. Should have 1 match.
   int ordinal = 0;
   TabContents* tab = browser()->GetSelectedTabContents();
   EXPECT_EQ(1, FindInPageWchar(tab, L"page", kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 
   // Simulate what happens when you press F3 for FindNext. Still should show
   // one match. This cleared the pre-populate string at one point (see bug).
   EXPECT_EQ(1, ui_test_utils::FindInPage(tab, string16(),
                                          kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 
   // End the Find session, thereby making the next F3 start afresh.
-  browser()->GetFindBarController()->EndFindSession();
+  browser()->GetFindBarController()->EndFindSession(
+      FindBarController::kKeepSelection);
 
   // Simulate F3 while Find box is closed. Should have 1 match.
   EXPECT_EQ(1, FindInPageWchar(tab, L"", kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 }
 
 // When re-opening the find bar with F3, the find bar should be re-populated
 // with the last search from the same tab rather than the last overall search.
 // http://crbug.com/30006
 #if defined(OS_CHROMEOS)
 #define PreferPreviousSearch FLAKY_PreferPreviousSearch
 #endif
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, PreferPreviousSearch) {
   HTTPTestServer* server = StartHTTPServer();
 
+#if defined(TOOLKIT_VIEWS)
   DropdownBarHost::disable_animations_during_testing_ = true;
+#endif
 
   // First we navigate to any page.
   GURL url = server->TestServerPageW(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Find "Default".
   int ordinal = 0;
   TabContents* tab1 = browser()->GetSelectedTabContents();
   EXPECT_EQ(1, FindInPageWchar(tab1, L"Default", kFwd, kIgnoreCase, &ordinal));
 
   // Create a second tab.
   browser()->AddTabWithURL(url, GURL(), PageTransition::TYPED, true, -1,
       false, NULL);
   browser()->SelectTabContentsAt(1, false);
   TabContents* tab2 = browser()->GetSelectedTabContents();
   EXPECT_NE(tab1, tab2);
 
   // Find "given".
   FindInPageWchar(tab2, L"given", kFwd, kIgnoreCase, &ordinal);
 
   // Switch back to first tab.
   browser()->SelectTabContentsAt(0, false);
-  browser()->GetFindBarController()->EndFindSession();
+  browser()->GetFindBarController()->EndFindSession(
+      FindBarController::kKeepSelection);
   // Simulate F3.
   ui_test_utils::FindInPage(tab1, string16(), kFwd, kIgnoreCase, &ordinal);
   EXPECT_EQ(tab1->find_text(), WideToUTF16(L"Default"));
 }
+
+// This makes sure that dismissing the find bar with kActivateSelection works.
+IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, ActivateLinkNavigatesPage) {
+  HTTPTestServer* server = StartHTTPServer();
+
+#if defined(TOOLKIT_VIEWS)
+  DropdownBarHost::disable_animations_during_testing_ = true;
+#endif
+
+  // First we navigate to our test content.
+  GURL url = server->TestServerPageW(kLinkPage);
+  ui_test_utils::NavigateToURL(browser(), url);
+
+  TabContents* tab = browser()->GetSelectedTabContents();
+  int ordinal = 0;
+  FindInPageWchar(tab, L"link", kFwd, kIgnoreCase, &ordinal);
+  EXPECT_EQ(ordinal, 1);
+
+  // End the find session, click on the link.
+  tab->StopFinding(FindBarController::kActivateSelection);
+  EXPECT_TRUE(ui_test_utils::WaitForNavigationInCurrentTab(browser()));
+}