[Autofill] Migrate ContentPasswordManagerDriver<-->Password{Autofill,Generation}Agent IPCs to mojo.

chrome/renderer/autofill/password_autofill_agent_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/feature_list.h"
 #include "base/macros.h"
+#include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/renderer/autofill/fake_content_password_manager_driver.h"
 #include "chrome/renderer/autofill/password_generation_test_utils.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/autofill_agent.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/test_password_autofill_agent.h"
 #include "components/autofill/content/renderer/test_password_generation_agent.h"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include <components/autofill/core/common/password_form.h>
 #include "components/autofill/core/common/password_form_field_prediction_map.h"
 #include "components/password_manager/core/common/password_manager_features.h"
 #include "content/public/renderer/render_frame.h"
+#include "content/public/renderer/render_view.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/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.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/WebNode.h"
@@ skipping 185 matching lines @@
     "  <INPUT type='password' id='password2' name='password'/>"
     "  <INPUT type='submit' value='Login'/>"
     "</FORM>";
 
 // Sets the "readonly" attribute of |element| to the value given by |read_only|.
 void SetElementReadOnly(WebInputElement& element, bool read_only) {
   element.setAttribute(WebString::fromUTF8("readonly"),
                        read_only ? WebString::fromUTF8("true") : WebString());
 }
 
+enum PasswordFormSourceType {
+  PasswordFormSubmitted,
+  PasswordFormInPageNavigation,
+};
+
 }  // namespace
 
 namespace autofill {
 
 class PasswordAutofillAgentTest : public ChromeRenderViewTest {
  public:
   PasswordAutofillAgentTest() {
   }
 
   // Simulates the fill password form message being sent to the renderer.
   // We use that so we don't have to make RenderView::OnFillPasswordForm()
   // protected.
   void SimulateOnFillPasswordForm(
       const PasswordFormFillData& fill_data) {
-    AutofillMsg_FillPasswordForm msg(0, kPasswordFillFormDataId, fill_data);
-    static_cast<IPC::Listener*>(password_autofill_agent_)
-        ->OnMessageReceived(msg);
-  }
-
-  // As above, but fills for an iframe.
-  void SimulateOnFillPasswordFormForFrame(
-      WebFrame* frame,
-      const PasswordFormFillData& fill_data) {
-    AutofillMsg_FillPasswordForm msg(0, kPasswordFillFormDataId, fill_data);
-    content::RenderFrame::FromWebFrame(frame)->OnMessageReceived(msg);
+    password_autofill_agent_->FillPasswordForm(kPasswordFillFormDataId,
+                                               fill_data);
   }
 
   // Simulates the show initial password account suggestions message being sent
   // to the renderer.
   void SimulateOnShowInitialPasswordAccountSuggestions(
       const PasswordFormFillData& fill_data) {
     autofill_agent_->ShowInitialPasswordAccountSuggestions(
         kPasswordFillFormDataId, fill_data);
   }
 
@@ skipping 52 matching lines @@
     // Now retrieve the input elements so the test can access them.
     UpdateUsernameAndPasswordElements();
   }
 
   void TearDown() override {
     username_element_.reset();
     password_element_.reset();
     ChromeRenderViewTest::TearDown();
   }
 
+  void RegisterMainFrameRemoteInterfaces() override {
+    // 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::PasswordManagerDriver::Name_,
+        base::Bind(&PasswordAutofillAgentTest::BindPasswordManagerDriver,
+                   base::Unretained(this)));
+  }
+
   void SetFillOnAccountSelect() {
     base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->InitializeFromCommandLine(
         password_manager::features::kFillOnAccountSelect.name, "");
     base::FeatureList::SetInstance(std::move(feature_list));
   }
 
   void UpdateOriginForHTML(const std::string& html) {
     std::string origin = "data:text/html;charset=utf-8," + html;
@@ skipping 36 matching lines @@
     SimulateSuggestionChoiceOfUsernameAndPassword(username_input, username,
                                                   password);
   }
 
   void SimulateSuggestionChoiceOfUsernameAndPassword(
       WebInputElement& input,
       const base::string16& username,
       const base::string16& password) {
     // This call is necessary to setup the autofill agent appropriate for the
     // user selection; simulates the menu actually popping up.
-    render_thread_->sink().ClearMessages();
     static_cast<autofill::PageClickListener*>(autofill_agent_)
         ->FormControlElementClicked(input, false);
 
     autofill_agent_->FillPasswordSuggestion(username, password);
   }
 
   void SimulateUsernameChange(const std::string& username) {
     SimulateUserInputChangeForElement(&username_element_, username);
   }
 
@@ skipping 52 matching lines @@
   void CheckUsernameSelection(int start, int end) {
     EXPECT_EQ(start, username_element_.selectionStart());
     EXPECT_EQ(end, username_element_.selectionEnd());
   }
 
   // Checks the message sent to PasswordAutofillManager to build the suggestion
   // list. |username| is the expected username field value, and |show_all| is
   // the expected flag for the PasswordAutofillManager, whether to show all
   // suggestions, or only those starting with |username|.
   void CheckSuggestions(const std::string& username, bool show_all) {
-    const IPC::Message* message =
-        render_thread_->sink().GetFirstMessageMatching(
-            AutofillHostMsg_ShowPasswordSuggestions::ID);
-    ASSERT_TRUE(message);
-    std::tuple<int, base::i18n::TextDirection, base::string16, int, gfx::RectF>
-        args;
-    AutofillHostMsg_ShowPasswordSuggestions::Read(message, &args);
-    EXPECT_EQ(kPasswordFillFormDataId, std::get<0>(args));
-    EXPECT_EQ(ASCIIToUTF16(username), std::get<2>(args));
+    base::RunLoop().RunUntilIdle();
+
+    ASSERT_TRUE(fake_driver_.called_show_pw_suggestions());
+    EXPECT_EQ(kPasswordFillFormDataId, fake_driver_.show_pw_suggestions_key());
+    ASSERT_TRUE(static_cast<bool>(fake_driver_.show_pw_suggestions_username()));
+    EXPECT_EQ(ASCIIToUTF16(username),
+              *(fake_driver_.show_pw_suggestions_username()));
     EXPECT_EQ(show_all,
-              static_cast<bool>(std::get<3>(args) & autofill::SHOW_ALL));
+              static_cast<bool>(fake_driver_.show_pw_suggestions_options() &
+                                autofill::SHOW_ALL));
 
-    render_thread_->sink().ClearMessages();
+    fake_driver_.reset_show_pw_suggestions();
+  }
+
+  bool GetCalledShowPasswordSuggestions() {
+    base::RunLoop().RunUntilIdle();
+    return fake_driver_.called_show_pw_suggestions();
   }
 
   void ExpectFormSubmittedWithUsernameAndPasswords(
       const std::string& username_value,
       const std::string& password_value,
       const std::string& new_password_value) {
-    const IPC::Message* message =
-        render_thread_->sink().GetFirstMessageMatching(
-            AutofillHostMsg_PasswordFormSubmitted::ID);
-    ASSERT_TRUE(message);
-    std::tuple<autofill::PasswordForm> args;
-    AutofillHostMsg_PasswordFormSubmitted::Read(message, &args);
-    EXPECT_EQ(ASCIIToUTF16(username_value), std::get<0>(args).username_value);
-    EXPECT_EQ(ASCIIToUTF16(password_value), std::get<0>(args).password_value);
-    EXPECT_EQ(ASCIIToUTF16(new_password_value),
-              std::get<0>(args).new_password_value);
+    base::RunLoop().RunUntilIdle();
+    ASSERT_TRUE(fake_driver_.called_password_form_submitted());
+    ASSERT_TRUE(static_cast<bool>(fake_driver_.password_form_submitted()));
+    const autofill::PasswordForm& form =
+        *(fake_driver_.password_form_submitted());
+    EXPECT_EQ(ASCIIToUTF16(username_value), form.username_value);
+    EXPECT_EQ(ASCIIToUTF16(password_value), form.password_value);
+    EXPECT_EQ(ASCIIToUTF16(new_password_value), form.new_password_value);
   }
 
   void ExpectFieldPropertiesMasks(
-      uint32_t expected_message_id,
+      PasswordFormSourceType expected_type,
       const std::map<base::string16, FieldPropertiesMask>&
           expected_properties_masks) {
-    const IPC::Message* message =
-        render_thread_->sink().GetFirstMessageMatching(expected_message_id);
-    ASSERT_TRUE(message);
-    std::tuple<autofill::PasswordForm> args;
-    AutofillHostMsg_PasswordFormSubmitted::Read(message, &args);
-    const autofill::PasswordForm& form = std::get<0>(args);
+    base::RunLoop().RunUntilIdle();
+    autofill::PasswordForm form;
+    if (expected_type == PasswordFormSubmitted) {
+      ASSERT_TRUE(fake_driver_.called_password_form_submitted());
+      ASSERT_TRUE(static_cast<bool>(fake_driver_.password_form_submitted()));
+      form = *(fake_driver_.password_form_submitted());
+    } else if (expected_type == PasswordFormInPageNavigation) {
+      ASSERT_TRUE(fake_driver_.called_inpage_navigation());
+      ASSERT_TRUE(
+          static_cast<bool>(fake_driver_.password_form_inpage_navigation()));
+      form = *(fake_driver_.password_form_inpage_navigation());
+    } else {
+      ASSERT_TRUE(expected_type == PasswordFormSubmitted ||

[vabr (Chromium), 2016/08/10 14:00:52]

This is not what I meant. While it improves the information logged by the
ASSERT, it feels strange to repeat all the conditions, and there is a risk of
the ASSERT going out of sync with the structure of the if-else block. My
suggestion was:

if (expected_type == PasswordFormSubmitted) {
  ...
} else {
  ASSERT_EQ(PasswordFormInPageNavigation, expected_type);
  ASSERT_TRUE(fake_driver_.called_inpage_navigation());
  ASSERT_TRUE(
      static_cast<bool>(fake_driver_.password_form_inpage_navigation()));
  form = *(fake_driver_.password_form_inpage_navigation());
}

Note that the last "else" disappeared completely, and the last "else if" changed
into just "else", with the ASSERT_EQ verifying what used to be the "else
if"-condition. The test will abort at failing ASSERT*, so the rest of the code
in that else branch can safely assume that expected_type ==
PasswordFormInPageNavigation.

(Also note the use of ASSERT_EQ instead of ASSERT_TRUE(...==...), for an even
more informative log message.)

[leonhsl(Using Gerrit), 2016/08/11 06:29:55]

Oh I see. Thanks a lot for detailed explanation ;-) Done.

+                  expected_type == PasswordFormInPageNavigation);
+    }
 
     size_t unchecked_masks = expected_properties_masks.size();
     for (const FormFieldData& field : form.form_data.fields) {
       const auto& it = expected_properties_masks.find(field.name);
       if (it == expected_properties_masks.end())
         continue;
       EXPECT_EQ(field.properties_mask, it->second)
           << "Wrong mask for the field " << field.name;
       unchecked_masks--;
     }
     EXPECT_TRUE(unchecked_masks == 0)
         << "Some expected masks are missed in FormData";
   }
 
   void ExpectInPageNavigationWithUsernameAndPasswords(
       const std::string& username_value,
       const std::string& password_value,
       const std::string& new_password_value) {
-    const IPC::Message* message =
-        render_thread_->sink().GetFirstMessageMatching(
-            AutofillHostMsg_InPageNavigation::ID);
-    ASSERT_TRUE(message);
-    std::tuple<autofill::PasswordForm> args;
-    AutofillHostMsg_InPageNavigation::Read(message, &args);
-    EXPECT_EQ(ASCIIToUTF16(username_value), std::get<0>(args).username_value);
-    EXPECT_EQ(ASCIIToUTF16(password_value), std::get<0>(args).password_value);
-    EXPECT_EQ(ASCIIToUTF16(new_password_value),
-              std::get<0>(args).new_password_value);
+    base::RunLoop().RunUntilIdle();
+    ASSERT_TRUE(fake_driver_.called_inpage_navigation());
+    ASSERT_TRUE(
+        static_cast<bool>(fake_driver_.password_form_inpage_navigation()));
+    const autofill::PasswordForm& form =
+        *(fake_driver_.password_form_inpage_navigation());
+    EXPECT_EQ(ASCIIToUTF16(username_value), form.username_value);
+    EXPECT_EQ(ASCIIToUTF16(password_value), form.password_value);
+    EXPECT_EQ(ASCIIToUTF16(new_password_value), form.new_password_value);
   }
 
+  void BindPasswordManagerDriver(mojo::ScopedMessagePipeHandle handle) {
+    fake_driver_.BindRequest(
+        mojo::MakeRequest<mojom::PasswordManagerDriver>(std::move(handle)));
+  }
+
+  FakeContentPasswordManagerDriver fake_driver_;
+
   base::string16 username1_;
   base::string16 username2_;
   base::string16 username3_;
   base::string16 password1_;
   base::string16 password2_;
   base::string16 password3_;
   base::string16 alternate_username3_;
   PasswordFormFillData fill_data_;
 
   WebInputElement username_element_;
@@ skipping 272 matching lines @@
   EXPECT_FALSE(form_util::IsWebNodeVisible(forms2[0]));
 
   LoadHTML(kNonVisibleFormHTML);
   frame = GetMainFrame();
   frame->document().forms(forms3);
   ASSERT_EQ(1u, forms3.size());
   EXPECT_FALSE(form_util::IsWebNodeVisible(forms3[0]));
 }
 
 TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest) {
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_password_forms_rendered();
   LoadHTML(kVisibleFormWithNoUsernameHTML);
-  const IPC::Message* message = render_thread_->sink()
-      .GetFirstMessageMatching(AutofillHostMsg_PasswordFormsRendered::ID);
-  EXPECT_TRUE(message);
-  std::tuple<std::vector<autofill::PasswordForm>, bool> param;
-  AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_TRUE(std::get<0>(param).size());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(fake_driver_.called_password_forms_rendered());
+  ASSERT_TRUE(static_cast<bool>(fake_driver_.password_forms_rendered()));
+  EXPECT_FALSE(fake_driver_.password_forms_rendered()->empty());
 
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_password_forms_rendered();
   LoadHTML(kEmptyFormHTML);
-  message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_PasswordFormsRendered::ID);
-  EXPECT_TRUE(message);
-  AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_FALSE(std::get<0>(param).size());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(fake_driver_.called_password_forms_rendered());
+  ASSERT_TRUE(static_cast<bool>(fake_driver_.password_forms_rendered()));
+  EXPECT_TRUE(fake_driver_.password_forms_rendered()->empty());
 
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_password_forms_rendered();
   LoadHTML(kNonVisibleFormHTML);
-  message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_PasswordFormsRendered::ID);
-  EXPECT_TRUE(message);
-  AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_FALSE(std::get<0>(param).size());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(fake_driver_.called_password_forms_rendered());
+  ASSERT_TRUE(static_cast<bool>(fake_driver_.password_forms_rendered()));
+  EXPECT_TRUE(fake_driver_.password_forms_rendered()->empty());
 }
 
 TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest_Redirection) {
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_password_forms_rendered();
   LoadHTML(kEmptyWebpage);
-  EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_PasswordFormsRendered::ID));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(fake_driver_.called_password_forms_rendered());
 
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_password_forms_rendered();
   LoadHTML(kRedirectionWebpage);
-  EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_PasswordFormsRendered::ID));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(fake_driver_.called_password_forms_rendered());
 
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_password_forms_rendered();
   LoadHTML(kSimpleWebpage);
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_PasswordFormsRendered::ID));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(fake_driver_.called_password_forms_rendered());
 
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_password_forms_rendered();
   LoadHTML(kWebpageWithDynamicContent);
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_PasswordFormsRendered::ID));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(fake_driver_.called_password_forms_rendered());
 }
 
 // Tests that a password will only be filled as a suggested and will not be
 // accessible by the DOM until a user gesture has occurred.
 TEST_F(PasswordAutofillAgentTest, GestureRequiredTest) {
   // Trigger the initial autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   // The username and password should have been autocompleted.
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
@@ skipping 334 matching lines @@
   EXPECT_TRUE(username_element_.suggestedValue().isEmpty());
   EXPECT_FALSE(username_element_.isAutofilled());
   EXPECT_TRUE(password_element_.value().isEmpty());
   EXPECT_TRUE(password_element_.suggestedValue().isEmpty());
   EXPECT_FALSE(password_element_.isAutofilled());
   CheckUsernameSelection(0, 0);
 }
 
 // Tests that logging is off by default.
 TEST_F(PasswordAutofillAgentTest, OnChangeLoggingState_NoMessage) {
-  render_thread_->sink().ClearMessages();
   SendVisiblePasswordForms();
-  const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_RecordSavePasswordProgress::ID);
-  EXPECT_FALSE(message);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(fake_driver_.called_record_save_progress());
 }
 
 // Test that logging can be turned on by a message.
 TEST_F(PasswordAutofillAgentTest, OnChangeLoggingState_Activated) {
   // Turn the logging on.
-  AutofillMsg_SetLoggingState msg_activate(0, true);
-  // Up-cast to access OnMessageReceived, which is private in the agent.
-  EXPECT_TRUE(static_cast<IPC::Listener*>(password_autofill_agent_)
-                  ->OnMessageReceived(msg_activate));
+  password_autofill_agent_->SetLoggingState(true);
 
-  render_thread_->sink().ClearMessages();
   SendVisiblePasswordForms();
-  const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_RecordSavePasswordProgress::ID);
-  EXPECT_TRUE(message);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(fake_driver_.called_record_save_progress());
 }
 
 // Test that logging can be turned off by a message.
 TEST_F(PasswordAutofillAgentTest, OnChangeLoggingState_Deactivated) {
   // Turn the logging on and then off.
-  AutofillMsg_SetLoggingState msg_activate(0, /*active=*/true);
-  // Up-cast to access OnMessageReceived, which is private in the agent.
-  EXPECT_TRUE(static_cast<IPC::Listener*>(password_autofill_agent_)
-                  ->OnMessageReceived(msg_activate));
-  AutofillMsg_SetLoggingState msg_deactivate(0, /*active=*/false);
-  EXPECT_TRUE(static_cast<IPC::Listener*>(password_autofill_agent_)
-                  ->OnMessageReceived(msg_deactivate));
+  password_autofill_agent_->SetLoggingState(true);
+  password_autofill_agent_->SetLoggingState(false);
 
-  render_thread_->sink().ClearMessages();
   SendVisiblePasswordForms();
-  const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_RecordSavePasswordProgress::ID);
-  EXPECT_FALSE(message);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(fake_driver_.called_record_save_progress());
 }
 
 // Test that the agent sends an IPC call to get the current activity state of
 // password saving logging soon after construction.
 TEST_F(PasswordAutofillAgentTest, SendsLoggingStateUpdatePingOnConstruction) {
-  const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_PasswordAutofillAgentConstructed::ID);
-  EXPECT_TRUE(message);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(fake_driver_.called_agent_constructed());
 }
 
 // Tests that one user click on a username field is sufficient to bring up a
 // credential suggestion popup, and the user can autocomplete the password by
 // selecting the credential from the popup.
 TEST_F(PasswordAutofillAgentTest, ClickAndSelect) {
   // SimulateElementClick() is called so that a user gesture is actually made
   // and the password can be filled. However, SimulateElementClick() does not
   // actually lead to the AutofillAgent's InputElementClicked() method being
   // called, so SimulateSuggestionChoice has to manually call
@@ skipping 18 matching lines @@
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
   // Call SimulateElementClick() to produce a user gesture on the page so
   // autofill will actually fill.
   SimulateElementClick(kUsernameName);
 
   // Simulate a user clicking on the username element. This should produce a
   // message with all the usernames.
-  render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(username_element_, false);
   CheckSuggestions(std::string(), false);
 
   // Now simulate a user typing in an unrecognized username and then
   // clicking on the username element. This should also produce a message with
   // all the usernames.
   SimulateUsernameChange("baz");
-  render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(username_element_, true);
   CheckSuggestions("baz", true);
   ClearUsernameAndPasswordFields();
 }
 
 // Tests that there is an autosuggestion from the password manager when the
 // user clicks on the password field when FillOnAccountSelect is enabled.
 TEST_F(PasswordAutofillAgentTest,
        FillOnAccountSelectOnlyNoCredentialsOnPasswordClick) {
   SetFillOnAccountSelect();
 
   // Simulate the browser sending back the login info.
   SimulateOnShowInitialPasswordAccountSuggestions(fill_data_);
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
   // Call SimulateElementClick() to produce a user gesture on the page so
   // autofill will actually fill.
   SimulateElementClick(kUsernameName);
 
   // Simulate a user clicking on the password element. This should produce no
   // message.
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_show_pw_suggestions();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(password_element_, false);
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordSuggestions::ID));
+  EXPECT_TRUE(GetCalledShowPasswordSuggestions());
 }
 
 // Tests the autosuggestions that are given when a password element is clicked,
 // the username element is not editable, and FillOnAccountSelect is enabled.
 // Specifically, tests when the user clicks on the password element after page
 // load, and the corresponding username element is readonly (and thus
 // uneditable), that the credentials for the already-filled username are
 // suggested.
 TEST_F(PasswordAutofillAgentTest,
        FillOnAccountSelectOnlyCredentialsOnPasswordClick) {
@@ skipping 10 matching lines @@
   username_element_.setValue("alicia");
   SetElementReadOnly(username_element_, true);
 
   // Call SimulateElementClick() to produce a user gesture on the page so
   // autofill will actually fill.
   SimulateElementClick(kUsernameName);
 
   // Simulate a user clicking on the password element. This should produce a
   // dropdown with suggestion of all available usernames and so username
   // filter will be the empty string.
-  render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(password_element_, false);
   CheckSuggestions("", false);
 }
 
 // Tests that there is an autosuggestion from the password manager when the
 // user clicks on the password field.
 TEST_F(PasswordAutofillAgentTest, NoCredentialsOnPasswordClick) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
   // Call SimulateElementClick() to produce a user gesture on the page so
   // autofill will actually fill.
   SimulateElementClick(kUsernameName);
 
   // Simulate a user clicking on the password element. This should produce no
   // message.
-  render_thread_->sink().ClearMessages();
+  fake_driver_.reset_show_pw_suggestions();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(password_element_, false);
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordSuggestions::ID));
+  EXPECT_TRUE(GetCalledShowPasswordSuggestions());
 }
 
 // The user types in a username and a password, but then just before sending
 // the form off, a script clears them. This test checks that
 // PasswordAutofillAgent can still remember the username and the password
 // typed by the user.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyUsernameAndPasswordOnSubmit_ScriptCleared) {
   SimulateUsernameChange("temp");
   SimulatePasswordChange("random");
@@ skipping 125 matching lines @@
       ->WillSubmitForm(username_element_.form());
 
   std::map<base::string16, FieldPropertiesMask> expected_properties_masks;
   expected_properties_masks[ASCIIToUTF16("random_field")] =
       FieldPropertiesFlags::NO_FLAGS;
   expected_properties_masks[ASCIIToUTF16("username")] =
       FieldPropertiesFlags::USER_TYPED;
   expected_properties_masks[ASCIIToUTF16("password")] =
       FieldPropertiesFlags::USER_TYPED | FieldPropertiesFlags::HAD_FOCUS;
 
-  ExpectFieldPropertiesMasks(AutofillHostMsg_PasswordFormSubmitted::ID,
-                             expected_properties_masks);
+  ExpectFieldPropertiesMasks(PasswordFormSubmitted, expected_properties_masks);
 }
 
 TEST_F(PasswordAutofillAgentTest, RememberFieldPropertiesOnInPageNavigation) {
   LoadHTML(kNoFormHTML);
   UpdateUsernameAndPasswordElements();
 
   SimulateUsernameChange("Bob");
   SimulatePasswordChange("mypassword");
 
   username_element_.setAttribute("style", "display:none;");
   password_element_.setAttribute("style", "display:none;");
 
   password_autofill_agent_->AJAXSucceeded();
 
   std::map<base::string16, FieldPropertiesMask> expected_properties_masks;
   expected_properties_masks[ASCIIToUTF16("username")] =
       FieldPropertiesFlags::USER_TYPED;
   expected_properties_masks[ASCIIToUTF16("password")] =
       FieldPropertiesFlags::USER_TYPED | FieldPropertiesFlags::HAD_FOCUS;
 
-  ExpectFieldPropertiesMasks(AutofillHostMsg_InPageNavigation::ID,
+  ExpectFieldPropertiesMasks(PasswordFormInPageNavigation,
                              expected_properties_masks);
 }
 
 // The username/password is autofilled by password manager then just before
 // sending the form off, a script changes them. This test checks that
 // PasswordAutofillAgent can still get the username and the password autofilled.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastAutofilledUsernameAndPasswordOnSubmit_ScriptChanged) {
   SimulateOnFillPasswordForm(fill_data_);
 
@@ skipping 218 matching lines @@
   // Simulate the browser sending back the login info for an initial page load.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Do not show popup suggesstion when the password field is not-empty and not
   // autofilled.
   password_element_.setValue("123");
   password_element_.setAutofilled(false);
 
   SimulateSuggestionChoiceOfUsernameAndPassword(
       password_element_, base::string16(), ASCIIToUTF16(kAlicePassword));
-  ASSERT_FALSE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordSuggestions::ID));
+  ASSERT_FALSE(GetCalledShowPasswordSuggestions());
 }
 
 // Tests with fill-on-account-select enabled that if the username element is
 // read-only and filled with an unknown username, then the password field is not
 // highlighted as autofillable (regression test for https://crbug.com/442564).
 TEST_F(PasswordAutofillAgentTest,
        FillOnAccountSelectOnlyReadonlyUnknownUsername) {
   SetFillOnAccountSelect();
 
   ClearUsernameAndPasswordFields();
@@ skipping 36 matching lines @@
   blink::WebFormElement form_element = username_element_.form();
   FormData form_data;
   ASSERT_TRUE(WebFormElementToFormData(
       form_element, blink::WebFormControlElement(), nullptr,
       form_util::EXTRACT_NONE, &form_data, nullptr));
   // Simulate Autofill predictions: the first field is username, the third
   // one is password.
   std::map<autofill::FormData, PasswordFormFieldPredictionMap> predictions;
   predictions[form_data][form_data.fields[0]] = PREDICTION_USERNAME;
   predictions[form_data][form_data.fields[2]] = PREDICTION_NEW_PASSWORD;
-  AutofillMsg_AutofillUsernameAndPasswordDataReceived msg(0, predictions);
-  static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
-      ->OnMessageReceived(msg);
+  password_autofill_agent_->AutofillUsernameAndPasswordDataReceived(
+      predictions);
 
   // The predictions should still match even if the form changes, as long
   // as the particular elements don't change.
   std::string add_field_to_form =
       "var form = document.getElementById('LoginTestForm');"
       "var new_input = document.createElement('input');"
       "new_input.setAttribute('type', 'text');"
       "new_input.setAttribute('id', 'other_field');"
       "form.appendChild(new_input);";
   ExecuteJavaScriptForTests(add_field_to_form.c_str());
@@ skipping 51 matching lines @@
 // generation both trigger. Regression test for https://crbug.com/493455.
 TEST_F(PasswordAutofillAgentTest,
        PasswordGenerationTriggered_GeneratedPassword) {
   SimulateOnFillPasswordForm(fill_data_);
 
   SetNotBlacklistedMessage(password_generation_, kFormHTML);
   SetAccountCreationFormsDetectedMessage(password_generation_,
                                          GetMainFrame()->document(), 0, 2);
 
   base::string16 password = base::ASCIIToUTF16("NewPass22");
-  AutofillMsg_GeneratedPasswordAccepted msg(0, password);
-  static_cast<IPC::Listener*>(password_generation_)->OnMessageReceived(msg);
+  password_generation_->GeneratedPasswordAccepted(password);
 
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSendSubmitEvent(username_element_.form());
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(username_element_.form());
 
   ExpectFormSubmittedWithUsernameAndPasswords(kAliceUsername, "NewPass22", "");
 }
 
 // If password generation is enabled for a field, password autofill should not
@@ skipping 20 matching lines @@
   // Simulate generation triggering.
   SetNotBlacklistedMessage(password_generation_,
                            kSignupFormHTML);
   SetAccountCreationFormsDetectedMessage(password_generation_,
                                          GetMainFrame()->document(), 0, 1);
 
   // Simulate the field being clicked to start typing. This should trigger
   // generation but not password autofill.
   SetFocused(password_element_);
   SimulateElementClick("new_password");
-  EXPECT_EQ(nullptr,
-            render_thread_->sink().GetFirstMessageMatching(
-                AutofillHostMsg_ShowPasswordSuggestions::ID));
+  EXPECT_FALSE(GetCalledShowPasswordSuggestions());
   EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_ShowPasswordGenerationPopup::ID));
 }
 
 // Tests that a password change form is properly filled with the username and
 // password.
 TEST_F(PasswordAutofillAgentTest, FillSuggestionPasswordChangeForms) {
   LoadHTML(kPasswordChangeFormHTML);
   UpdateOriginForHTML(kPasswordChangeFormHTML);
   UpdateUsernameAndPasswordElements();
@@ skipping 41 matching lines @@
   LoadHTML(kPasswordChangeFormHTML);
   UpdateOriginForHTML(kPasswordChangeFormHTML);
   UpdateUsernameAndPasswordElements();
 
   ClearUsernameAndPasswordFields();
   fill_data_.wait_for_username = true;
   fill_data_.is_possible_change_password_form = true;
   SimulateOnFillPasswordForm(fill_data_);
   // Simulate a user clicking on the username element. This should produce a
   // message.
-  render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(username_element_, true);
   CheckSuggestions("", true);
 }
 
 // Tests that one user click on a password field is sufficient to bring up a
 // credential suggestion popup on a change password form.
 TEST_F(PasswordAutofillAgentTest,
        SuggestionsOnPasswordFieldOfChangePasswordForm) {
   LoadHTML(kPasswordChangeFormHTML);
   UpdateOriginForHTML(kPasswordChangeFormHTML);
   UpdateUsernameAndPasswordElements();
 
   ClearUsernameAndPasswordFields();
   fill_data_.wait_for_username = true;
   fill_data_.is_possible_change_password_form = true;
   SimulateOnFillPasswordForm(fill_data_);
   // Simulate a user clicking on the password element. This should produce a
   // message.
-  render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(password_element_, true);
   CheckSuggestions("", false);
 }
 
 // Tests that NOT_PASSWORD field predictions are followed so that no password
 // form is submitted.
 TEST_F(PasswordAutofillAgentTest, IgnoreNotPasswordFields) {
   LoadHTML(kCreditCardFormHTML);
   blink::WebInputElement credit_card_owner_element =
       GetInputElementByID(kCreditCardOwnerName);
   blink::WebInputElement credit_card_number_element =
       GetInputElementByID(kCreditCardNumberName);
   blink::WebInputElement credit_card_verification_element =
       GetInputElementByID(kCreditCardVerificationName);
   SimulateUserInputChangeForElement(&credit_card_owner_element, "JohnSmith");
   SimulateUserInputChangeForElement(&credit_card_number_element,
                                     "1234123412341234");
   SimulateUserInputChangeForElement(&credit_card_verification_element, "123");
   // Find FormData for visible form.
   blink::WebFormElement form_element = credit_card_number_element.form();
   FormData form_data;
   ASSERT_TRUE(WebFormElementToFormData(
       form_element, blink::WebFormControlElement(), nullptr,
       form_util::EXTRACT_NONE, &form_data, nullptr));
   // Simulate Autofill predictions: the third field is not a password.
   std::map<autofill::FormData, PasswordFormFieldPredictionMap> predictions;
   predictions[form_data][form_data.fields[2]] = PREDICTION_NOT_PASSWORD;
-  AutofillMsg_AutofillUsernameAndPasswordDataReceived msg(0, predictions);
-  static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
-      ->OnMessageReceived(msg);
+  password_autofill_agent_->AutofillUsernameAndPasswordDataReceived(
+      predictions);
 
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSendSubmitEvent(form_element);
   static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
       ->WillSubmitForm(form_element);
 
-  const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_PasswordFormSubmitted::ID);
-  ASSERT_FALSE(message);
+  base::RunLoop().RunUntilIdle();
+  ASSERT_FALSE(fake_driver_.called_password_form_submitted());
 }
 
 // Tests that only the password field is autocompleted when the browser sends
 // back data with only one credentials and empty username.
 TEST_F(PasswordAutofillAgentTest, NotAutofillNoUsername) {
   fill_data_.username_field.value.clear();
   fill_data_.additional_logins.clear();
   SimulateOnFillPasswordForm(fill_data_);
 
   CheckTextFieldsState("", false, kAlicePassword, true);
@@ skipping 29 matching lines @@
 TEST_F(PasswordAutofillAgentTest,
        NoForm_NoPromptForAJAXSubmitWithoutNavigationAndElementsVisible) {
   LoadHTML(kNoFormHTML);
   UpdateUsernameAndPasswordElements();
 
   SimulateUsernameChange("Bob");
   SimulatePasswordChange("mypassword");
 
   password_autofill_agent_->AJAXSucceeded();
 
-  const IPC::Message* message =
-      render_thread_->sink().GetFirstMessageMatching(
-          AutofillHostMsg_PasswordFormSubmitted::ID);
-  ASSERT_FALSE(message);
+  base::RunLoop().RunUntilIdle();
+  ASSERT_FALSE(fake_driver_.called_password_form_submitted());
 }
 
 // Tests that credential suggestions are autofilled on a password (and change
 // password) forms having either ambiguous or empty name.
 TEST_F(PasswordAutofillAgentTest,
        SuggestionsOnFormContainingAmbiguousOrEmptyNames) {
   const char kEmpty[] = "";
   const char kDummyUsernameField[] = "anonymous_username";
   const char kDummyPasswordField[] = "anonymous_password";
   const char kFormContainsEmptyNamesHTML[] =
@@ skipping 226 matching lines @@
 TEST_F(PasswordAutofillAgentTest, SuggestPasswordFieldSignInForm) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Call SimulateElementClick() to produce a user gesture on the page so
   // autofill will actually fill.
   SimulateElementClick(kUsernameName);
 
   // Simulate a user clicking on the password element. This should produce a
   // dropdown with suggestion of all available usernames.
-  render_thread_->sink().ClearMessages();
   static_cast<PageClickListener*>(autofill_agent_)
       ->FormControlElementClicked(password_element_, false);
   CheckSuggestions("", false);
 }
 
 // Tests that a suggestion dropdown is shown on each password field. But when a
 // user chose one of the fields to autofill, a suggestion dropdown will be shown
 // only on this field.
 TEST_F(PasswordAutofillAgentTest, SuggestMultiplePasswordFields) {
   LoadHTML(kPasswordChangeFormHTML);
   UpdateOriginForHTML(kPasswordChangeFormHTML);
   UpdateUsernameAndPasswordElements();
 
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Call SimulateElementClick() to produce a user gesture on the page so
   // autofill will actually fill.
   SimulateElementClick(kUsernameName);
 
   // Simulate a user clicking on the password elements. This should produce
   // dropdowns with suggestion of all available usernames.
-  render_thread_->sink().ClearMessages();
   SimulateElementClick("password");
   CheckSuggestions("", false);
 
   SimulateElementClick("newpassword");
   CheckSuggestions("", false);
 
   SimulateElementClick("confirmpassword");
   CheckSuggestions("", false);
 
   // The user chooses to autofill the current password field.
   EXPECT_TRUE(password_autofill_agent_->FillSuggestion(
       password_element_, ASCIIToUTF16(kAliceUsername),
       ASCIIToUTF16(kAlicePassword)));
 
   // Simulate a user clicking on not autofilled password fields. This should
-  // produce
-  // no suggestion dropdowns.
-  render_thread_->sink().ClearMessages();
+  // produce no suggestion dropdowns.
+  fake_driver_.reset_show_pw_suggestions();
   SimulateElementClick("newpassword");
   SimulateElementClick("confirmpassword");
-  EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordSuggestions::ID));
+  EXPECT_FALSE(GetCalledShowPasswordSuggestions());
 
   // But when the user clicks on the autofilled password field again it should
   // still produce a suggestion dropdown.
   SimulateElementClick("password");
   CheckSuggestions("", false);
 }
 
 }  // namespace autofill