Making BrowserFocusTest FocusTraversal faster

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 "base/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_window.h"
@@ skipping 129 matching lines @@
 
     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_dom_response_(false),
+        waiting_for_focus_change_(false) {
     FilePath file_path;
     bool r = PathService::Get(chrome::DIR_TEST_DATA, &file_path);
     EXPECT_TRUE(r);
     file_path = file_path.AppendASCII("focus");
     file_path = file_path.AppendASCII(kTypicalPageName);
     r = file_util::ReadFileToString(file_path, &html_contents_);
     EXPECT_TRUE(r);
   }
 
   virtual std::string GetHTMLContents() {
@@ skipping 24 matching lines @@
         dom_response_[dom_response_.size() - 1] == '"') {
       dom_response_ = dom_response_.substr(1, dom_response_.size() - 2);
     }
     return dom_response_;
   }
 
   bool HasFocus() {
     return render_view_host()->view()->HasFocus();
   }
 
+  void WaitForFocusChange() {
+    waiting_for_focus_change_ = true;
+    ui_test_utils::RunMessageLoop();
+  }
+
+ protected:
+  virtual void FocusedNodeChanged() {
+    if (!waiting_for_focus_change_)
+      return;
+
+    waiting_for_focus_change_= false;
+    MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+  }
+
  private:
   std::string html_contents_;
 
   bool waiting_for_dom_response_;
+  bool waiting_for_focus_change_;
   std::string dom_response_;
 
 };
 
 }  // namespace
 
 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.
@@ skipping 180 matching lines @@
   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);
 }
 
 // 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);
 
     // Now let's press tab to move the focus.
-    for (int j = 0; j < 7; ++j) {
+    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));
       ASSERT_STREQ(kExpElementIDs[j], actual.c_str());
 
-      ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_TAB, false,
-                                              false, false,
-                                              new MessageLoop::QuitTask());
-      ui_test_utils::RunMessageLoop();
-      // Ideally, we wouldn't sleep here and instead would use the event
-      // processed ack notification from the renderer.  I am reluctant to create
-      // a new notification/callback for that purpose just for this test.
-      PlatformThread::Sleep(kActionDelayMs);
+      ASSERT_TRUE(ui_controls::SendKeyPress(window, base::VKEY_TAB,
+                                            false, false, false));
+
+      if (j < arraysize(kExpElementIDs) - 1) {
+        ui_test_utils::WaitForFocusChange(browser()->GetSelectedTabContents()->
+            render_view_host());
+      } 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()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
-    ui_test_utils::RunMessageLoop();
+    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);
 
     // Now let's press shift-tab to move the focus in reverse.
-    for (int j = 0; j < 7; ++j) {
-      ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_TAB, false,
-                                              true, false,
-                                              new MessageLoop::QuitTask());
-      ui_test_utils::RunMessageLoop();
-      PlatformThread::Sleep(kActionDelayMs);
+    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 {
+        // On the last tab key press, the focus returns to the browser.
+        ui_test_utils::WaitForFocusInBrowser(browser());
+      }
 
       // 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));
       ASSERT_STREQ(kExpElementIDs[6 - j], actual.c_str());
     }
 
     // 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()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
-    ui_test_utils::RunMessageLoop();
+    MessageLoop::current()->RunAllPending();
   }
 }
 
 // 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);
@@ skipping 22 matching lines @@
   };
 
   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);
 
     // Now let's press tab to move the focus.
-    for (int j = 0; j < 7; ++j) {
+    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());
 
-      ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_TAB, false,
-                                              false, false,
-                                              new MessageLoop::QuitTask());
-      ui_test_utils::RunMessageLoop();
-      // Ideally, we wouldn't sleep here and instead would use the event
-      // processed ack notification from the renderer.  I am reluctant to create
-      // a new notification/callback for that purpose just for this test.
-      PlatformThread::Sleep(kActionDelayMs);
+      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()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
-    ui_test_utils::RunMessageLoop();
+    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);
 
     // Now let's press shift-tab to move the focus in reverse.
-    for (int j = 0; j < 7; ++j) {
-      ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_TAB, false,
-                                              true, false,
-                                              new MessageLoop::QuitTask());
-      ui_test_utils::RunMessageLoop();
-      PlatformThread::Sleep(kActionDelayMs);
+    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.
+        ui_test_utils::WaitForFocusInBrowser(browser());
+      }
 
       // Let's make sure the focus is on the expected element in the page.
       std::string actual = interstitial_page->GetFocusedElement();
       ASSERT_STREQ(kExpElementIDs[6 - j], actual.c_str());
     }
 
     // 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()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
-    ui_test_utils::RunMessageLoop();
+    MessageLoop::current()->RunAllPending();
   }
 }
 
 // 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);
@@ skipping 127 matching lines @@
 
   // 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);
 }