[Autofill] Migrate ContentAutofillDriver<-->AutofillAgent IPCs to mojo.

chrome/renderer/autofill/autofill_renderer_browsertest.cc

 // Copyright (c) 2012 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 <tuple>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "chrome/test/base/ui_test_utils.h"
-#include "components/autofill/content/common/autofill_messages.h"
+#include "components/autofill/content/public/interfaces/autofill_driver.mojom.h"
 #include "components/autofill/content/renderer/autofill_agent.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/renderer/render_frame.h"
+#include "content/public/renderer/render_view.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
+#include "services/shell/public/cpp/interface_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 using base::ASCIIToUTF16;
 using blink::WebDocument;
 using blink::WebElement;
 using blink::WebFormElement;
 using blink::WebFrame;
 using blink::WebLocalFrame;
 using blink::WebInputElement;
 using blink::WebString;
 using blink::WebURLRequest;
 using blink::WebVector;
 
 namespace autofill {
 
+namespace {
+
+class FakeContentAutofillDriver : public mojom::AutofillDriver {
+ public:
+  FakeContentAutofillDriver() : called_fieldchange_(false) {}
+  ~FakeContentAutofillDriver() override {}
+
+  void BindRequest(mojom::AutofillDriverRequest request) {
+    bindings_.AddBinding(this, std::move(request));
+  }
+
+  // Records whether TextFieldDidChange() get called.
+  bool called_fieldchange_;

[yzshen1, 2016/06/29 22:25:44]

nit: Please use setter/getter instead of making the fields public.
We usually only do that for simple structs.

(Here and other files in this CL)

[leonhsl(Using Gerrit), 2016/07/01 13:04:59]

Done for all files in this CL.

+  // Records data received via FormSeen() call.
+  std::unique_ptr<std::vector<FormData>> forms_;
+
+ private:
+  // mojom::AutofillDriver:
+  void FirstUserGestureObserved() override {}
+
+  void FormsSeen(mojo::Array<FormData> forms,
+                 const base::TimeTicks& timestamp) override {
+    // FormsSeen() could be called multiple times and sometimes even with empty
+    // forms array for main frame, but we're interested in only the first time
+    // call.
+    if (!forms_)
+      forms_.reset(new std::vector<FormData>(forms.PassStorage()));
+  }
+
+  void WillSubmitForm(const FormData& form,
+                      const base::TimeTicks& timestamp) override {}
+
+  void FormSubmitted(const FormData& form) override {}
+
+  void TextFieldDidChange(const FormData& form,
+                          const FormFieldData& field,
+                          const base::TimeTicks& timestamp) override {
+    called_fieldchange_ = true;
+  }
+
+  void QueryFormFieldAutofill(int32_t id,
+                              const FormData& form,
+                              const FormFieldData& field,
+                              const gfx::RectF& bounding_box) override {}
+
+  void HidePopup() override {}
+
+  void PingAck() override {}
+
+  void FocusNoLongerOnForm() override {}
+
+  void DidFillAutofillFormData(const FormData& form,
+                               const base::TimeTicks& timestamp) override {}
+
+  void DidPreviewAutofillFormData() override {}
+
+  void DidEndTextFieldEditing() override {}
+
+  void SetDataList(mojo::Array<mojo::String> values,
+                   mojo::Array<mojo::String> labels) override {}
+
+  mojo::BindingSet<mojom::AutofillDriver> bindings_;
+};
+
+}  // namespace
+
 using AutofillQueryParam =
     std::tuple<int, autofill::FormData, autofill::FormFieldData, gfx::RectF>;
 
 class AutofillRendererTest : public ChromeRenderViewTest {
  public:
   AutofillRendererTest() {}
+
   ~AutofillRendererTest() override {}
 
  protected:
   void SetUp() override {
     ChromeRenderViewTest::SetUp();
+
+    // We only use the fake driver for main frame
+    // because our test cases only involve the main frame.
+    shell::InterfaceProvider* remote_interfaces =
+        view_->GetMainRenderFrame()->GetRemoteInterfaces();
+    shell::InterfaceProvider::TestApi test_api(remote_interfaces);
+    test_api.SetBinderForName(
+        mojom::AutofillDriver::Name_,
+        base::Bind(&AutofillRendererTest::BindAutofillDriver,
+                   base::Unretained(this)));
   }
 
+  void BindAutofillDriver(mojo::ScopedMessagePipeHandle handle) {
+    fake_driver_.BindRequest(
+        mojo::MakeRequest<mojom::AutofillDriver>(std::move(handle)));
+  }
+
+  FakeContentAutofillDriver fake_driver_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(AutofillRendererTest);
 };
 
 TEST_F(AutofillRendererTest, SendForms) {
   LoadHTML("<form method='POST'>"
            "  <input type='text' id='firstname'/>"
            "  <input type='text' id='middlename'/>"
            "  <input type='text' id='lastname' autoComplete='off'/>"
            "  <input type='hidden' id='email'/>"
            "  <select id='state'/>"
            "    <option>?</option>"
            "    <option>California</option>"
            "    <option>Texas</option>"
            "  </select>"
            "</form>");
 
+  base::RunLoop run_loop;
+  run_loop.RunUntilIdle();

[yzshen1, 2016/06/29 22:25:44]

Please note that we don't guarantee that the message loop stays busy.
The more reliable way is to let the fake_driver_ quit the run loop. (here and
elsewhere)

   // Verify that "FormsSeen" sends the expected number of fields.
-  const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_FormsSeen::ID);
-  ASSERT_NE(nullptr, message);
-  AutofillHostMsg_FormsSeen::Param params;
-  AutofillHostMsg_FormsSeen::Read(message, &params);
-  std::vector<FormData> forms = std::get<0>(params);
+  ASSERT_TRUE(fake_driver_.forms_);
+  std::vector<FormData> forms = *(fake_driver_.forms_.get());
   ASSERT_EQ(1UL, forms.size());
   ASSERT_EQ(4UL, forms[0].fields.size());
 
   FormFieldData expected;
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = base::string16();
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, forms[0].fields[0]);
@@ skipping 11 matching lines @@
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, forms[0].fields[2]);
   expected.autocomplete_attribute = std::string();  // reset
 
   expected.name = ASCIIToUTF16("state");
   expected.value = ASCIIToUTF16("?");
   expected.form_control_type = "select-one";
   expected.max_length = 0;
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, forms[0].fields[3]);
 
-  render_thread_->sink().ClearMessages();
+  fake_driver_.forms_.reset();
 
   // Dynamically create a new form. A new message should be sent for it, but
   // not for the previous form.
   ExecuteJavaScriptForTests(
       "var newForm=document.createElement('form');"
       "newForm.id='new_testform';"
       "newForm.action='http://google.com';"
       "newForm.method='post';"
       "var newFirstname=document.createElement('input');"
       "newFirstname.setAttribute('type', 'text');"
       "newFirstname.setAttribute('id', 'second_firstname');"
       "newFirstname.value = 'Bob';"
       "var newLastname=document.createElement('input');"
       "newLastname.setAttribute('type', 'text');"
       "newLastname.setAttribute('id', 'second_lastname');"
       "newLastname.value = 'Hope';"
       "var newEmail=document.createElement('input');"
       "newEmail.setAttribute('type', 'text');"
       "newEmail.setAttribute('id', 'second_email');"
       "newEmail.value = 'bobhope@example.com';"
       "newForm.appendChild(newFirstname);"
       "newForm.appendChild(newLastname);"
       "newForm.appendChild(newEmail);"
       "document.body.appendChild(newForm);");
   base::RunLoop().RunUntilIdle();
 
-  message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_FormsSeen::ID);
-  ASSERT_NE(nullptr, message);
-  AutofillHostMsg_FormsSeen::Read(message, &params);
-  forms = std::get<0>(params);
+  ASSERT_TRUE(fake_driver_.forms_);
+  forms = *(fake_driver_.forms_.get());
   ASSERT_EQ(1UL, forms.size());
   ASSERT_EQ(3UL, forms[0].fields.size());
 
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("second_firstname");
   expected.value = ASCIIToUTF16("Bob");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, forms[0].fields[0]);
 
   expected.name = ASCIIToUTF16("second_lastname");
   expected.value = ASCIIToUTF16("Hope");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, forms[0].fields[1]);
 
   expected.name = ASCIIToUTF16("second_email");
   expected.value = ASCIIToUTF16("bobhope@example.com");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, forms[0].fields[2]);
 }
 
 TEST_F(AutofillRendererTest, EnsureNoFormSeenIfTooFewFields) {
   LoadHTML("<form method='POST'>"
            "  <input type='text' id='firstname'/>"
            "  <input type='text' id='middlename'/>"
            "</form>");
 
+  base::RunLoop run_loop;
+  run_loop.RunUntilIdle();
   // Verify that "FormsSeen" isn't sent, as there are too few fields.
-  const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_FormsSeen::ID);
-  ASSERT_NE(nullptr, message);
-  AutofillHostMsg_FormsSeen::Param params;
-  AutofillHostMsg_FormsSeen::Read(message, &params);
-  const std::vector<FormData>& forms = std::get<0>(params);
+  ASSERT_TRUE(fake_driver_.forms_);
+  const std::vector<FormData>& forms = *(fake_driver_.forms_.get());
   ASSERT_EQ(0UL, forms.size());
 }
 
 // Regression test for [ http://crbug.com/346010 ].
 TEST_F(AutofillRendererTest, DontCrashWhileAssociatingForms) {
   LoadHTML("<form id='form'>"
            "<foo id='foo'>"
            "<script id='script'>"
            "document.documentElement.appendChild(foo);"
            "newDoc = document.implementation.createDocument("
            "    'http://www.w3.org/1999/xhtml', 'html');"
            "foo.insertBefore(form, script);"
            "newDoc.adoptNode(foo);"
            "</script>");
 
   // Shouldn't crash.
 }
 
 TEST_F(AutofillRendererTest, DynamicallyAddedUnownedFormElements) {
   std::string html_data;
   base::FilePath test_path = ui_test_utils::GetTestFilePath(
       base::FilePath(FILE_PATH_LITERAL("autofill")),
       base::FilePath(FILE_PATH_LITERAL("autofill_noform_dynamic.html")));
   ASSERT_TRUE(base::ReadFileToString(test_path, &html_data));
   LoadHTML(html_data.c_str());
 
+  base::RunLoop run_loop;
+  run_loop.RunUntilIdle();
   // Verify that "FormsSeen" sends the expected number of fields.
-  const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_FormsSeen::ID);
-  ASSERT_NE(nullptr, message);
-  AutofillHostMsg_FormsSeen::Param params;
-  AutofillHostMsg_FormsSeen::Read(message, &params);
-  std::vector<FormData> forms = std::get<0>(params);
+  ASSERT_TRUE(fake_driver_.forms_);
+  std::vector<FormData> forms = *(fake_driver_.forms_.get());
   ASSERT_EQ(1UL, forms.size());
   ASSERT_EQ(7UL, forms[0].fields.size());
 
-  render_thread_->sink().ClearMessages();
+  fake_driver_.forms_.reset();
 
   ExecuteJavaScriptForTests("AddFields()");
   base::RunLoop().RunUntilIdle();
 
-  message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_FormsSeen::ID);
-  ASSERT_NE(nullptr, message);
-  AutofillHostMsg_FormsSeen::Read(message, &params);
-  forms = std::get<0>(params);
+  ASSERT_TRUE(fake_driver_.forms_);
+  forms = *(fake_driver_.forms_.get());
   ASSERT_EQ(1UL, forms.size());
   ASSERT_EQ(9UL, forms[0].fields.size());
 
   FormFieldData expected;
 
   expected.name = ASCIIToUTF16("EMAIL_ADDRESS");
   expected.value.clear();
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, forms[0].fields[7]);
@@ skipping 11 matching lines @@
            "</form>");
 
   blink::WebInputElement full_name =
       GetMainFrame()->document().getElementById("full_name")
           .to<blink::WebInputElement>();
   while (!full_name.focused())
     GetMainFrame()->view()->advanceFocus(false);
 
   // Not a user gesture, so no IPC message to browser.
   DisableUserGestureSimulationForAutofill();
+  ASSERT_FALSE(fake_driver_.called_fieldchange_);
   full_name.setValue("Alice", true);
   GetMainFrame()->autofillClient()->textFieldDidChange(full_name);
   base::RunLoop().RunUntilIdle();
-  ASSERT_EQ(nullptr, render_thread_->sink().GetFirstMessageMatching(
-                         AutofillHostMsg_TextFieldDidChange::ID));
+  ASSERT_FALSE(fake_driver_.called_fieldchange_);
 
   // A user gesture will send a message to the browser.
   EnableUserGestureSimulationForAutofill();
   SimulateUserInputChangeForElement(&full_name, "Alice");
-  ASSERT_NE(nullptr, render_thread_->sink().GetFirstMessageMatching(
-                         AutofillHostMsg_TextFieldDidChange::ID));
+  ASSERT_TRUE(fake_driver_.called_fieldchange_);
 }
 
 }  // namespace autofill