Browser Side Text Input State Tracking for OOPIF.

chrome/browser/apps/guest_view/web_view_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 <queue>
 #include <utility>
 
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/path_service.h"
@@ skipping 337 matching lines @@
   content::WebContentsDelegate* orig_delegate_;
   bool waiting_for_decision_;
   bool expect_allow_;
   bool decision_made_;
   bool last_download_allowed_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MockDownloadWebContentsDelegate);
 };
 
+class TextInputStateHelper {
+ public:
+  using Predicate =
+      base::Callback<bool(const content::TextInputStateTestExport&)>;
+
+  static void WaitForDesiredState(content::WebContents* web_contents,
+                                  const Predicate& predicate) {
+    content::TextInputStateTestExport state =
+        content::TextInputStateTestExport::FromWebContents(web_contents);
+    while (!predicate.Run(state)) {
+      scoped_refptr<content::MessageLoopRunner> loop =
+          new content::MessageLoopRunner();
+      content::BrowserThread::PostDelayedTask(
+          content::BrowserThread::UI, FROM_HERE, loop->QuitClosure(),
+          base::TimeDelta::FromMilliseconds(1LL));
+      loop->Run();
+      state = content::TextInputStateTestExport::FromWebContents(web_contents);
+    }
+  }
+
+  static bool IsStateOfGivenType(
+      ui::TextInputType type,
+      const content::TextInputStateTestExport& state) {
+    return type == state.type();
+  }
+
+  static bool HasGivenValue(const std::string& value,
+                            const content::TextInputStateTestExport& state) {
+    return value == state.value();
+  }
+};
+
 // TODO(wjmaclean): Fix this test class at some point so it can be re-enabled on
 // the site isolation bots, and then look at re-enabling WebViewFocusTest when
 // that happens.
 // https://crbug.com/503751
 class WebViewTestBase : public extensions::PlatformAppBrowserTest {
  protected:
   void SetUp() override {
     if (UsesFakeSpeech()) {
       // SpeechRecognition test specific SetUp.
       fake_speech_recognition_manager_.reset(
@@ skipping 406 matching lines @@
   void SetUpCommandLine(base::CommandLine* command_line) override {
     WebViewTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(switches::kForceDeviceScaleFactor,
                                     base::StringPrintf("%f", scale()));
     command_line->AppendSwitch(switches::kEnableUseZoomForDSF);
   }
 
   static float scale() { return 2.0f; }
 };
 
+// TODO(ekaramad): Enable this test for OOPIF.
+class WebViewTextInputStateTest : public WebViewTest {};
+INSTANTIATE_TEST_CASE_P(WebViewTests,
+                        WebViewTextInputStateTest,
+                        testing::Bool());
+
 class WebContentsAudioMutedObserver : public content::WebContentsObserver {
  public:
   explicit WebContentsAudioMutedObserver(content::WebContents* web_contents)
       : WebContentsObserver(web_contents),
         loop_runner_(new content::MessageLoopRunner),
         muting_update_observed_(false) {}
 
   // WebContentsObserver.
   void DidUpdateAudioMutingState(bool muted) override {
     muting_update_observed_ = true;
@@ skipping 2315 matching lines @@
   // 4 tasks expected. The order is arbitrary.
   // Tab: about:blank,
   // Background Page: <webview> task manager test,
   // App: <webview> task manager test,
   // Webview: WebViewed test content.
   EXPECT_EQ(4U, task_manager.tasks().size());
   EXPECT_TRUE(HasExpectedGuestTask(task_manager, guest_contents));
 }
 
 #endif  // defined(ENABLE_TASK_MANAGER)
+
+// TODO(ekaramad): Activate this test for OOPIF when input event routing for
+// OOPIF-<webview> is fixed.
+IN_PROC_BROWSER_TEST_P(WebViewTextInputStateTest,
+                       TopLevelWebContentsTracksCorrectly) {
+  if (content::BrowserPluginGuestMode::UseCrossProcessFramesForGuests())
+    return;
+
+  ASSERT_TRUE(StartEmbeddedTestServer());
+
+  EXPECT_TRUE(!!LoadGuest(
+      "/extensions/platform_apps/web_view/text_input_state/guest.html",
+      "web_view/text_input_state"));
+
+  auto press_tab = [](content::WebContents* web_contents) {
+    content::SimulateKeyPress(web_contents, ui::VKEY_TAB, false, false, false,
+                              false);
+  };
+
+  auto get_type_checker = [](ui::TextInputType target) {
+    return base::Bind(&TextInputStateHelper::IsStateOfGivenType, target);
+  };
+
+  content::WebContents* embedder_webcontents = GetEmbedderWebContents();
+
+  // Press the tab key. The <input> in the embedder should get focused.
+  // Top level state type should be number.
+  press_tab(embedder_webcontents);
+  TextInputStateHelper::WaitForDesiredState(

[lazyboy, 2016/04/04 19:17:59]

Generally, queuing tasks to wait for a change is discouraged.

How about you have a "focus" handler in the embedder's 2016 text box and send a
message to the test and then verify TextInputStateTestExport's state is the
correct one? That way you don't have to do the busy wait thingy:

in embedder:
inputElement.onfocus = function() { chrome.testSendMessage('FOCUSED'); }
ExtensionTestMessageListener listener("FOCUSED");
press_tab();
listener.WaitUntilSatisfied();

If this works, then do the same for other steps below.

[EhsanK, 2016/04/06 00:37:58]

(As discussed offline) I now listen to 'onfocus()' for inputs and then start
polling the text input state.

(As discussed offline 2) The test now lives in
web_view_interactive_browsertest.cc (due to tab key simulation issues on Mac).

+      GetEmbedderWebContents(), get_type_checker(ui::TEXT_INPUT_TYPE_NUMBER));
+
+  // Press the tab key again and the <input> inside <webview> gets focused. The
+  // input type should text now.
+  press_tab(embedder_webcontents);
+  TextInputStateHelper::WaitForDesiredState(
+      GetEmbedderWebContents(), get_type_checker(ui::TEXT_INPUT_TYPE_TEXT));
+
+  // Press the tab key one more time to get back to embedder's second <input>.
+  // The value should be "last one".
+  press_tab(embedder_webcontents);
+  TextInputStateHelper::WaitForDesiredState(
+      GetEmbedderWebContents(),
+      base::Bind(&TextInputStateHelper::HasGivenValue, "last one"));
+}
+
+// TODO(ekaramad): Activate this test for OOPIF when input event routing for
+// OOPIF-<webview> is fixed.
+IN_PROC_BROWSER_TEST_P(WebViewTextInputStateTest, CrashingWebViewResetsState) {
+  if (content::BrowserPluginGuestMode::UseCrossProcessFramesForGuests())
+    return;
+
+  ASSERT_TRUE(StartEmbeddedTestServer());
+
+  content::WebContents* guest_contents = LoadGuest(
+      "/extensions/platform_apps/web_view/text_input_state/guest.html",
+      "web_view/text_input_state");
+
+  // Press tab key twice to end up in the <input> of the <webview>,
+  for (size_t i = 0; i < 2; ++i) {
+    content::SimulateKeyPress(GetEmbedderWebContents(), ui::VKEY_TAB, false,
+                              false, false, false);
+  };
+
+  TextInputStateHelper::WaitForDesiredState(
+      GetEmbedderWebContents(),
+      base::Bind(&TextInputStateHelper::HasGivenValue, "guest"));
+
+  // Now crash the <webview>.
+  guest_contents->GetRenderProcessHost()->Shutdown(false, 0);
+
+  // State should reset to none.
+  TextInputStateHelper::WaitForDesiredState(
+      GetEmbedderWebContents(),
+      base::Bind(&TextInputStateHelper::IsStateOfGivenType,
+                 ui::TEXT_INPUT_TYPE_NONE));
+}