Extracting placeholder information from Webkit to Blimp

chrome/browser/renderer_host/site_per_process_text_input_browsertest.cc

 // Copyright 2016 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 <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/interactive_test_utils.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
+#include "content/public/common/form_field_data.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "content/public/test/text_input_test_utils.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "ui/base/ime/composition_underline.h"
 #include "ui/base/ime/text_edit_commands.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/ime/text_input_mode.h"
@@ skipping 237 matching lines @@
         OnSuccess();
     }
   }
 
   const content::RenderWidgetHostView* const expected_view_;
   const size_t expected_length_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewTextSelectionObserver);
 };
 
+// This class is used to verify the result of form field data requests.
+class FormFieldDataVerifier {
+ public:
+  FormFieldDataVerifier(const std::string& text, const std::string& placeholder)
+      : text_(text), placeholder_(placeholder), success_(false) {}
+
+  void Verify(const content::FormFieldData& field) {
+    ASSERT_EQ(field.text, text_);
+    ASSERT_EQ(field.placeholder, placeholder_);
+    OnSuccess();
+  }
+
+  // Wait for success_ to be true.
+  void Wait() {
+    if (success_)
+      return;
+    message_loop_runner_ = new content::MessageLoopRunner();
+    message_loop_runner_->Run();
+  }
+
+ private:
+  void OnSuccess() {
+    success_ = true;
+    if (message_loop_runner_)
+      message_loop_runner_->Quit();
+  }
+
+  std::string text_;
+  std::string placeholder_;
+
+  bool success_;
+  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(FormFieldDataVerifier);
+};
+
 // This class monitors all the changes in TextInputState and keeps a record of
 // the active views. There is no waiting and the recording process is
 // continuous.
 class RecordActiveViewsObserver {
  public:
   explicit RecordActiveViewsObserver(content::WebContents* web_contents)
       : tester_(new content::TextInputManagerTester(web_contents)) {
     tester_->SetUpdateTextInputStateCalledCallback(base::Bind(
         &RecordActiveViewsObserver::RecordActiveView, base::Unretained(this)));
   }
@@ skipping 55 matching lines @@
         "var input = document.createElement('input');"
         "input.setAttribute('type', '%s');"
         "input.setAttribute('value', '%s');"
         "document.body.%s;",
         type.c_str(), value.c_str(),
         append_as_first_child ? "insertBefore(input, document.body.firstChild)"
                               : "appendChild(input)");
     EXPECT_TRUE(ExecuteScript(rfh, script));
   }
 
+  // static
+  // Appends an <input> field with various attribues to a given frame by
+  // executing javascript code.
+  static void AppendInputFieldToFrame(content::RenderFrameHost* rfh,
+                                      const std::string& type,
+                                      const std::string& id,
+                                      const std::string& value,
+                                      const std::string& placeholder) {
+    std::string script = base::StringPrintf(
+        "var input = document.createElement('input');"
+        "input.setAttribute('type', '%s');"
+        "input.setAttribute('id', '%s');"
+        "input.setAttribute('value', '%s');"
+        "input.setAttribute('placeholder', '%s');"
+        "document.body.appendChild(input);",
+        type.c_str(), id.c_str(), value.c_str(), placeholder.c_str());
+    EXPECT_TRUE(ExecuteScript(rfh, script));
+  }
+
+  // static
+  // Focus a form field by its Id.
+  static void FocusFormField(content::RenderFrameHost* rfh,
+                             const std::string& id) {
+    std::string script = base::StringPrintf(
+        "document.getElementById('%s').focus();", id.c_str());
+
+    EXPECT_TRUE(ExecuteScript(rfh, script));
+  }
+
   // Uses 'cross_site_iframe_factory.html'. The main frame's domain is
   // 'a.com'.
   void CreateIframePage(const std::string& structure) {
     std::string path = base::StringPrintf("/cross_site_iframe_factory.html?%s",
                                           structure.c_str());
     GURL main_url(embedded_test_server()->GetURL("a.com", path));
     ui_test_utils::NavigateToURL(browser(), main_url);
   }
 
   // Iteratively uses ChildFrameAt(frame, i) to get the i-th child frame
@@ skipping 331 matching lines @@
   for (size_t i = 0; i < views.size(); ++i) {
     // First focus the <input>.
     send_tab_and_wait_for_value(values[i]);
 
     // Send a sequence of |count| 'E' keys and wait until the view receives a
     // selection change update for a text of the corresponding size, |count|.
     send_keys_select_all_wait_for_selection_change(views[i], count++);
   }
 }
 
+// This test creates a page with multiple child frames and adds two <input>
+// elements to each frame. Then, sequentially, each <input> is focused through
+// javascript. For each frame, its text and placeholder attributes are queried
+// through RenderFrameHost and verified against expected values.
+IN_PROC_BROWSER_TEST_F(SitePerProcessTextInputManagerTest,
+                       RequestFocusedFormFieldDataForMultipleIFrames) {
+  CreateIframePage("a(b, c)");
+  std::vector<content::RenderFrameHost*> frames{GetFrame(IndexVector{}),
+                                                GetFrame(IndexVector{0}),
+                                                GetFrame(IndexVector{1})};
+
+  std::vector<std::string> values{"main_1",   "main_2",   "node_b_1",
+                                  "node_b_2", "node_c_1", "node_c_2"};
+  std::vector<std::string> placeholders{
+      "placeholder_main_1",   "placeholder_main_2",   "placeholder_node_b_1",
+      "placeholder_node_b_2", "placeholder_node_c_1", "placeholder_node_c_2"};
+
+  for (size_t i = 0; i < values.size(); ++i) {
+    AppendInputFieldToFrame(frames[i / 2], "text", values[i], values[i],
+                            placeholders[i]);
+  }
+
+  for (size_t i = 0; i < values.size(); ++i) {
+    content::RenderFrameHost* frame = frames[i / 2];
+    FocusFormField(frame, values[i]);
+    FormFieldDataVerifier verifier(values[i], placeholders[i]);
+    content::FormFieldDataCallback callback =
+        base::Bind(&FormFieldDataVerifier::Verify, base::Unretained(&verifier));
+    frame->RequestFocusedFormFieldData(callback);
+    verifier.Wait();
+  }
+}
+
 // The following test verifies that when the active widget changes value, it is
 // always from nullptr to non-null or vice versa.
 IN_PROC_BROWSER_TEST_F(SitePerProcessTextInputManagerTest,
                        ResetTextInputStateOnActiveWidgetChange) {
   CreateIframePage("a(b,c(a,b),d)");
   std::vector<content::RenderFrameHost*> frames{
       GetFrame(IndexVector{}),     GetFrame(IndexVector{0}),
       GetFrame(IndexVector{1}),    GetFrame(IndexVector{1, 0}),
       GetFrame(IndexVector{1, 1}), GetFrame(IndexVector{2})};
   std::vector<content::RenderWidgetHostView*> views;
@@ skipping 408 matching lines @@
   // Test ends here. The rest is cleanup.
 
   // Closing this WebContents while we still hold on to our TestBrowserClient.
   EXPECT_TRUE(browser()->tab_strip_model()->CloseWebContentsAt(
       1, TabStripModel::CLOSE_USER_GESTURE));
 
   // For the cleanup of the original WebContents in tab index 0.
   content::SetBrowserClientForTesting(old_browser_client);
 }
 #endif