[Mac]Port browser_keyevents_browsertest.cc and browser_focus_uitest.cc to Mac.

chrome/browser/browser_focus_uitest.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 "build/build_config.h"
 
 #include "base/format_macros.h"
+#include "base/logging.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"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/tab_contents/interstitial_page.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
+
+#if defined(TOOLKIT_VIEWS) || defined(OS_WIN)
 #include "views/focus/focus_manager.h"
 #include "views/view.h"
 #include "views/window/window.h"
+#endif
 
 #if defined(TOOLKIT_VIEWS)
 #include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/views/location_bar/location_bar_view.h"
 #include "chrome/browser/views/tab_contents/tab_contents_container.h"
 #endif
 
 #if defined(TOOLKIT_USES_GTK)
 #include "chrome/browser/gtk/view_id_util.h"
 #endif
 
 #if defined(OS_LINUX)
+#define MAYBE_FocusTraversal FocusTraversal
 // For some reason we hit an external DNS lookup in this test in Linux but not
 // on Windows. TODO(estade): investigate.
 #define MAYBE_FocusTraversalOnInterstitial DISABLED_FocusTraversalOnInterstitial
 // TODO(jcampan): http://crbug.com/23683
 #define MAYBE_TabsRememberFocusFindInPage FAILS_TabsRememberFocusFindInPage
-#else
+#elif defined(OS_MACOSX)
+// TODO(suzhe): http://crbug.com/49738 (following two tests)
+#define MAYBE_FocusTraversal FAILS_FocusTraversal
+#define MAYBE_FocusTraversalOnInterstitial FAILS_FocusTraversalOnInterstitial
+// TODO(suzhe): http://crbug.com/49737
+#define MAYBE_TabsRememberFocusFindInPage FAILS_TabsRememberFocusFindInPage
+#elif defined(OS_WIN)
+#define MAYBE_FocusTraversal FocusTraversal
 #define MAYBE_FocusTraversalOnInterstitial FocusTraversalOnInterstitial
 #define MAYBE_TabsRememberFocusFindInPage TabsRememberFocusFindInPage
 #endif
 
 namespace {
 
 // The delay waited in some cases where we don't have a notifications for an
 // action we take.
 const int kActionDelayMs = 500;
 
@@ skipping 10 matching lines @@
   }
 
   bool IsViewFocused(ViewID vid) {
     return ui_test_utils::IsViewFocused(browser(), vid);
   }
 
   void ClickOnView(ViewID vid) {
     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(TOOLKIT_USES_GTK)
-    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(TOOLKIT_USES_GTK)
-    gtk_widget_hide(GTK_WIDGET(window));
-#else
-    NOTIMPLEMENTED();
-#endif
+  void BringBrowserWindowToFront() {
+    ui_test_utils::ShowAndFocusNativeWindow(
+        browser()->window()->GetNativeHandle());
   }
 };
 
 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;
@@ skipping 58 matching lines @@
   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(USE_X11)
+  BringBrowserWindowToFront();
+#if defined(USE_X11) || defined(OS_MACOSX)
   // 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
 
   ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   ClickOnView(VIEW_ID_TAB_CONTAINER);
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   ClickOnView(VIEW_ID_LOCATION_BAR);
   ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, BrowsersRememberFocus) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // First we navigate to our test page.
   GURL url = server->TestServerPage(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   gfx::NativeWindow window = browser()->window()->GetNativeHandle();
 
   // The focus should be on the Tab contents.
   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);
+  ui_test_utils::HideNativeWindow(window);
+  ui_test_utils::ShowAndFocusNativeWindow(window);
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   browser()->FocusLocationBar();
   ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
   // Hide the window, show it again, the focus should not have changed.
-  HideNativeWindow(window);
-  ShowNativeWindow(window);
+  ui_test_utils::HideNativeWindow(window);
+  ui_test_utils::ShowAndFocusNativeWindow(window);
   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();
@@ skipping 23 matching lines @@
   EXPECT_EQ(browser_view2->GetTabContentsContainerView(),
             focus_manager2->GetFocusedView());
 
   // Close the 2nd browser to avoid a DCHECK().
   browser_view2->Close();
 #endif
 }
 
 // Tabs remember focus.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, TabsRememberFocus) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // First we navigate to our test page.
   GURL url = server->TestServerPage(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Create several tabs.
   for (int i = 0; i < 4; ++i) {
     browser()->AddTabWithURL(url, GURL(), PageTransition::TYPED, -1,
                              TabStripModel::ADD_SELECTED, NULL, std::string());
   }
@@ skipping 53 matching lines @@
       ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_TAB, true,
                                               true, false, false,
                                               new MessageLoop::QuitTask());
       ui_test_utils::RunMessageLoop();
     }
   }
 }
 
 // Tabs remember focus with find-in-page box.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, MAYBE_TabsRememberFocusFindInPage) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // First we navigate to our test page.
   GURL url = server->TestServerPage(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   browser()->Find();
   ui_test_utils::FindInPage(browser()->GetSelectedTabContents(),
                             ASCIIToUTF16("a"), true, false, NULL);
   ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 
@@ skipping 17 matching lines @@
   browser()->Find();
   ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
   browser()->SelectTabContentsAt(1, true);
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
   browser()->SelectTabContentsAt(0, true);
   ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 }
 
 // Background window does not steal focus.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, BackgroundBrowserDontStealFocus) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // First we navigate to our test page.
   GURL url = server->TestServerPage(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Open a new browser window.
   Browser* browser2 = Browser::Create(browser()->profile());
   ASSERT_TRUE(browser2);
   browser2->tabstrip_model()->delegate()->AddBlankTab(true);
   browser2->window()->Show();
 
   Browser* focused_browser = NULL;
   Browser* unfocused_browser = NULL;
 #if defined(USE_X11)
   // On X11, calling Activate() is not guaranteed to move focus, so we have
   // to figure out which browser does have focus.
   if (browser2->window()->IsActive()) {
     focused_browser = browser2;
     unfocused_browser = browser();
   } else if (browser()->window()->IsActive()) {
     focused_browser = browser();
     unfocused_browser = browser2;
   } else {
     ASSERT_TRUE(false);
   }
 #elif defined(OS_WIN)
   focused_browser = browser();
   unfocused_browser = browser2;
+#elif defined(OS_MACOSX)
+  // On Mac, the newly created window always gets the focus.
+  focused_browser = browser2;
+  unfocused_browser = browser();
 #endif
 
   GURL steal_focus_url = server->TestServerPage(kStealFocusPage);
   ui_test_utils::NavigateToURL(unfocused_browser, steal_focus_url);
 
   // Activate the first browser.
   focused_browser->window()->Activate();
 
   // Wait for the focus to be stolen by the other browser.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, new MessageLoop::QuitTask(), 2000);
   ui_test_utils::RunMessageLoop();
 
   // Make sure the first browser is still active.
   EXPECT_TRUE(focused_browser->window()->IsActive());
 
   // Close the 2nd browser to avoid a DCHECK().
   browser2->window()->Close();
 }
 
 // Page cannot steal focus when focus is on location bar.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, LocationBarLockFocus) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // Open the page that steals focus.
   GURL url = server->TestServerPage(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.
   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) {
+IN_PROC_BROWSER_TEST_F(BrowserFocusTest, MAYBE_FocusTraversal) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // First we navigate to our test page.
   GURL url = server->TestServerPage(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).
@@ skipping 71 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.
     ui_test_utils::RunAllPendingInMessageLoop();
   }
 }
 
 // Focus traversal while an interstitial is showing.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, MAYBE_FocusTraversalOnInterstitial) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // First we navigate to our test page.
   GURL url = server->TestServerPage(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Focus should be on the page.
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Let's show an interstitial.
   TestInterstitialPage* interstitial_page =
@@ skipping 69 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.
     ui_test_utils::RunAllPendingInMessageLoop();
   }
 }
 
 // Focus stays on page with interstitials.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, InterstitialFocus) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // First we navigate to our test page.
   GURL url = server->TestServerPage(kSimplePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Page should have focus.
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
   EXPECT_TRUE(browser()->GetSelectedTabContents()->render_view_host()->view()->
       HasFocus());
 
@@ skipping 14 matching lines @@
 
   // Hide the interstitial.
   interstitial_page->DontProceed();
 
   // Focus should be back on the original page.
   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) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // Open some page (any page that doesn't steal focus).
   GURL url = server->TestServerPage(kTypicalPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   gfx::NativeWindow window = browser()->window()->GetNativeHandle();
 
+#if defined(OS_MACOSX)
+  // Press Cmd+F, which will make the Find box open and request focus.
+  ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, false,
+                                          false, false, true,
+                                          new MessageLoop::QuitTask());
+#else
   // Press Ctrl+F, which will make the Find box open and request focus.
   ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, true,
                                           false, false, false,
                                           new MessageLoop::QuitTask());
+#endif
   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();
 
   ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 
   browser()->FocusLocationBar();
   ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   // Now press Ctrl+F again and focus should move to the Find box.
+#if defined(OS_MACOSX)
+  ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, false,
+                                          false, false, true,
+                                          new MessageLoop::QuitTask());
+#else
   ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, true,
                                           false, false, false,
                                           new MessageLoop::QuitTask());
+#endif
   ui_test_utils::RunMessageLoop();
   ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 
   // Set focus to the page.
   ClickOnView(VIEW_ID_TAB_CONTAINER);
   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, false,
+#if defined(OS_MACOSX)
+  ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, false,
+                                          false, false, true,
                                           new MessageLoop::QuitTask());
+#else
+  ui_controls::SendKeyPressNotifyWhenDone(window, base::VKEY_F, true,
+                                          false, false, false,
+                                          new MessageLoop::QuitTask());
+#endif
   ui_test_utils::RunMessageLoop();
 
   // See remark above on why we wait.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, new MessageLoop::QuitTask(), kActionDelayMs);
   ui_test_utils::RunMessageLoop();
   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) {
+  BringBrowserWindowToFront();
   // Open the history tab, focus should be on the tab contents.
   browser()->ShowHistoryTab();
 
   ui_test_utils::RunAllPendingInMessageLoop();
 
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Open the new tab, focus should be on the location bar.
   browser()->NewTab();
   ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   // Open the download tab, focus should be on the tab contents.
   browser()->ShowDownloadsTab();
   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,
                            -1, TabStripModel::ADD_SELECTED, NULL,
                            std::string());
   ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 }
 
 // Tests that focus goes where expected when using reload.
 IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FocusOnReload) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // Open the new tab, reload.
   browser()->NewTab();
 
   ui_test_utils::RunAllPendingInMessageLoop();
 
   browser()->Reload(CURRENT_TAB);
   ASSERT_TRUE(ui_test_utils::WaitForNavigationInCurrentTab(browser()));
   // Focus should stay on the location bar.
   ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
 
   // Open a regular page, focus the location bar, reload.
   ui_test_utils::NavigateToURL(browser(), server->TestServerPage(kSimplePage));
   browser()->FocusLocationBar();
   ASSERT_TRUE(IsViewFocused(VIEW_ID_LOCATION_BAR));
   browser()->Reload(CURRENT_TAB);
   ASSERT_TRUE(ui_test_utils::WaitForNavigationInCurrentTab(browser()));
   // Focus should now be on the tab contents.
   browser()->ShowDownloadsTab();
   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) {
+  BringBrowserWindowToFront();
   HTTPTestServer* server = StartHTTPServer();
+  ASSERT_TRUE(server);
 
   // Open a regular page, crash, reload.
   ui_test_utils::NavigateToURL(browser(), server->TestServerPage(kSimplePage));
   ui_test_utils::CrashTab(browser()->GetSelectedTabContents());
   browser()->Reload(CURRENT_TAB);
   ASSERT_TRUE(ui_test_utils::WaitForNavigationInCurrentTab(browser()));
   // Focus should now be on the tab contents.
   browser()->ShowDownloadsTab();
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 }