Revert of 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