Implement WebContentsViewChildFrame::TakeFocus.

chrome/browser/apps/guest_view/web_view_interactive_browsertest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
@@ skipping 496 matching lines @@
           ::features::kGuestViewCrossProcessFrames.name);
     } else {
       command_line->AppendSwitchASCII(
           switches::kDisableFeatures,
           ::features::kGuestViewCrossProcessFrames.name);
     }
   }
 };
 
 class WebViewNewWindowInteractiveTest : public WebViewInteractiveTest {};
+class WebViewFocusInteractiveTest : public WebViewInteractiveTest {};
 class WebViewPointerLockInteractiveTest : public WebViewInteractiveTest {};
 
 // The tests below aren't needed in --use-cross-process-frames-for-guests.
 class WebViewContextMenuInteractiveTest : public WebViewInteractiveTestBase {};
 
 // The following class of tests do not work for OOPIF <webview>.
 // TODO(ekaramad): Make this tests work with OOPIF and replace the test classes
 // with WebViewInteractiveTest (see crbug.com/582562).
-class WebViewFocusInteractiveTest : public WebViewInteractiveTestBase {};
 class WebViewPopupInteractiveTest : public WebViewInteractiveTestBase {};
 class WebViewDragDropInteractiveTest : public WebViewInteractiveTestBase {};
 
 INSTANTIATE_TEST_CASE_P(WebViewInteractiveTests,
                         WebViewInteractiveTest,
                         testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(WebViewInteractiveTests,
                         WebViewNewWindowInteractiveTest,
                         testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(WebViewInteractiveTests,
+                        WebViewFocusInteractiveTest,
+                        testing::Bool());
+
+INSTANTIATE_TEST_CASE_P(WebViewInteractiveTests,
                         WebViewPointerLockInteractiveTest,
                         testing::Bool());
 
 // ui_test_utils::SendMouseMoveSync doesn't seem to work on OS_MACOSX, and
 // likely won't work on many other platforms as well, so for now this test
 // is for Windows and Linux only. As of Sept 17th, 2013 this test is disabled
 // on Windows due to flakines, see http://crbug.com/293445.
 
 // Disabled on Linux Aura because pointer lock does not work on Linux Aura.
 // crbug.com/341876
@@ skipping 93 matching lines @@
   SendKeyPressToPlatformApp(ui::VKEY_ESCAPE);
 
   // Wait for page to receive (successful) mouse unlock response.
   ASSERT_TRUE(unlocked_listener.WaitUntilSatisfied());
 }
 
 #endif  // defined(OS_LINUX)
 
 // Tests that if a <webview> is focused before navigation then the guest starts
 // off focused.
-IN_PROC_BROWSER_TEST_F(WebViewFocusInteractiveTest,
+IN_PROC_BROWSER_TEST_P(WebViewFocusInteractiveTest,
                        Focus_FocusBeforeNavigation) {
+  // TODO(avallee): Determine if test is relevant with OOPIF or fix the bug.
+  // http://crbug.com/672947
+  if (GetParam())
+    return;
   TestHelper("testFocusBeforeNavigation", "web_view/focus", NO_TEST_SERVER);
 }
 
 // Tests that setting focus on the <webview> sets focus on the guest.
-IN_PROC_BROWSER_TEST_F(WebViewFocusInteractiveTest, Focus_FocusEvent) {
+IN_PROC_BROWSER_TEST_P(WebViewFocusInteractiveTest, Focus_FocusEvent) {
   TestHelper("testFocusEvent", "web_view/focus", NO_TEST_SERVER);
 }
 
-IN_PROC_BROWSER_TEST_F(WebViewFocusInteractiveTest, Focus_FocusTracksEmbedder) {
+IN_PROC_BROWSER_TEST_P(WebViewFocusInteractiveTest, Focus_FocusTracksEmbedder) {
   content::WebContents* embedder_web_contents = NULL;
 
   std::unique_ptr<ExtensionTestMessageListener> done_listener(
       RunAppHelper("testFocusTracksEmbedder", "web_view/focus", NO_TEST_SERVER,
                    &embedder_web_contents));
   done_listener->WaitUntilSatisfied();
 
   ExtensionTestMessageListener next_step_listener("TEST_STEP_PASSED", false);
   next_step_listener.set_failure_message("TEST_STEP_FAILED");
   EXPECT_TRUE(content::ExecuteScript(
                   embedder_web_contents,
                   "window.runCommand('testFocusTracksEmbedderRunNextStep');"));
 
   // Blur the embedder.
   embedder_web_contents->GetRenderViewHost()->GetWidget()->Blur();
   // Ensure that the guest is also blurred.
   ASSERT_TRUE(next_step_listener.WaitUntilSatisfied());
 }
 
-IN_PROC_BROWSER_TEST_F(WebViewFocusInteractiveTest, Focus_AdvanceFocus) {
+IN_PROC_BROWSER_TEST_P(WebViewFocusInteractiveTest, Focus_AdvanceFocus) {
   content::WebContents* embedder_web_contents = NULL;
 
   {
     std::unique_ptr<ExtensionTestMessageListener> done_listener(
         RunAppHelper("testAdvanceFocus", "web_view/focus", NO_TEST_SERVER,
                      &embedder_web_contents));
     done_listener->WaitUntilSatisfied();
   }
 
   {
     ExtensionTestMessageListener listener("button1-focused", false);
     listener.set_failure_message("TEST_FAILED");
-    SimulateRWHMouseClick(
-        embedder_web_contents->GetRenderViewHost()->GetWidget(),
-        blink::WebMouseEvent::Button::Left, 200, 20);
+
+    // In oopif-webview, the click it directly routed to the guest.
+    content::WebContents* guest =
+        GetParam() ? GetGuestViewManager()->WaitForSingleGuestCreated()
+                   : nullptr;
+
+    SimulateRWHMouseClick((guest ? guest : embedder_web_contents)
+                              ->GetRenderViewHost()
+                              ->GetWidget(),
+                          blink::WebMouseEvent::Button::Left, 200, 20);
     content::SimulateKeyPress(embedder_web_contents, ui::DomKey::TAB,
                               ui::DomCode::TAB, ui::VKEY_TAB, false, false,
                               false, false);
     ASSERT_TRUE(listener.WaitUntilSatisfied());
   }
 
   {
     // Wait for button1 to be focused again, this means we were asked to
     // move the focus to the next focusable element.
     ExtensionTestMessageListener listener("button1-advance-focus", false);
@@ skipping 10 matching lines @@
                               ui::DomCode::TAB, ui::VKEY_TAB, false, false,
                               false, false);
     content::SimulateKeyPress(embedder_web_contents, ui::DomKey::TAB,
                               ui::DomCode::TAB, ui::VKEY_TAB, false, false,
                               false, false);
     ASSERT_TRUE(listener.WaitUntilSatisfied());
   }
 }
 
 // Tests that blurring <webview> also blurs the guest.
-IN_PROC_BROWSER_TEST_F(WebViewFocusInteractiveTest, Focus_BlurEvent) {
+IN_PROC_BROWSER_TEST_P(WebViewFocusInteractiveTest, Focus_BlurEvent) {
   TestHelper("testBlurEvent", "web_view/focus", NO_TEST_SERVER);
 }
 
 // Tests that guests receive edit commands and respond appropriately.
 IN_PROC_BROWSER_TEST_P(WebViewInteractiveTest, EditCommands) {
 #if defined(OS_MACOSX)
   // TODO(ekaramad): This test is failing under OOPIF in MAC.
   if (GetParam())
     return;
 #endif
@@ skipping 414 matching lines @@
 }
 
 // This test exercies the following scenario:
 // 1. An <input> in guest has focus.
 // 2. User takes focus to embedder by clicking e.g. an <input> in embedder.
 // 3. User brings back the focus directly to the <input> in #1.
 //
 // Now we need to make sure TextInputTypeChanged fires properly for the guest's
 // view upon step #3. We simply read the input type's state after #3 to
 // make sure it's not TEXT_INPUT_TYPE_NONE.
-IN_PROC_BROWSER_TEST_F(WebViewFocusInteractiveTest, Focus_FocusRestored) {
+IN_PROC_BROWSER_TEST_P(WebViewFocusInteractiveTest, Focus_FocusRestored) {
   TestHelper("testFocusRestored", "web_view/focus", NO_TEST_SERVER);
   content::WebContents* embedder_web_contents = GetFirstAppWindowWebContents();
   ASSERT_TRUE(embedder_web_contents);
   ASSERT_TRUE(guest_web_contents());
 
   // 1) We click on the guest so that we get a focus event.
   ExtensionTestMessageListener next_step_listener("TEST_STEP_PASSED", false);
   next_step_listener.set_failure_message("TEST_STEP_FAILED");
   {
     content::SimulateMouseClickAt(guest_web_contents(),
@@ skipping 156 matching lines @@
 }
 #endif
 
 // Flaky on MacOS builders. https://crbug.com/670008
 #if defined(OS_MACOSX)
 #define MAYBE_FocusAndVisibility DISABLED_FocusAndVisibility
 #else
 #define MAYBE_FocusAndVisibility FocusAndVisibility
 #endif
 
-IN_PROC_BROWSER_TEST_F(WebViewFocusInteractiveTest, MAYBE_FocusAndVisibility) {
+IN_PROC_BROWSER_TEST_P(WebViewFocusInteractiveTest, MAYBE_FocusAndVisibility) {
   ASSERT_TRUE(StartEmbeddedTestServer());
   LoadAndLaunchPlatformApp("web_view/focus_visibility",
                            "WebViewInteractiveTest.LOADED");
   ExtensionTestMessageListener test_init_listener(
       "WebViewInteractiveTest.WebViewInitialized", false);
   SendMessageToEmbedder("init");
   test_init_listener.WaitUntilSatisfied();
+
+  // In oopif-webview, wait until the tab key triggers a focus change.
+  std::unique_ptr<content::FrameFocusedObserver> frame_focus_observer =
+      GetParam() ? base::MakeUnique<content::FrameFocusedObserver>(
+                       GetGuestViewManager()
+                           ->WaitForSingleGuestCreated()
+                           ->GetMainFrame())
+                 : nullptr;
+
   // Send several tab-keys. The button inside webview should receive focus at
   // least once.
-  for (size_t i = 0; i < 4; ++i)
+  for (size_t i = 0; i < 2; ++i)
+    SendKeyPressToPlatformApp(ui::VKEY_TAB);
+  if (frame_focus_observer) {
+    frame_focus_observer->Wait();
+    frame_focus_observer.reset();
+  }
+  for (size_t i = 0; i < 2; ++i)
     SendKeyPressToPlatformApp(ui::VKEY_TAB);
   ExtensionTestMessageListener webview_button_focused_listener(
       "WebViewInteractiveTest.WebViewButtonWasFocused", false);
   webview_button_focused_listener.set_failure_message(
       "WebViewInteractiveTest.WebViewButtonWasNotFocused");
   SendMessageToEmbedder("verify");
   EXPECT_TRUE(webview_button_focused_listener.WaitUntilSatisfied());
   // Now make the <webview> invisible.
   ExtensionTestMessageListener reset_listener("WebViewInteractiveTest.DidReset",
                                               false);
@@ skipping 108 matching lines @@
   ASSERT_TRUE(ui_test_utils::SendKeyPressToWindowSync(
       GetPlatformAppWindow(), ui::VKEY_Z, false, false, false, false));
 
   next_step_listener.Reset();
   EXPECT_TRUE(content::ExecuteScript(
       embedder_web_contents(),
       "window.runCommand('testKeyboardFocusRunNextStep', 'aBcxYz');"));
 
   ASSERT_TRUE(next_step_listener.WaitUntilSatisfied());
 }