[Autofill] Migrate ChromePasswordManagerClient<-->PasswordGenerationAgent IPCs to mojo.

chrome/renderer/autofill/password_generation_agent_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 <string.h>
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/renderer/autofill/fake_content_password_manager_driver.h"
+#include "chrome/renderer/autofill/fake_password_manager_client.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/test_password_generation_agent.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/password_generation_util.h"
+#include "content/public/common/associated_interface_provider.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/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
@@ skipping 12 matching lines @@
   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(&PasswordGenerationAgentTest::BindPasswordManagerDriver,
                    base::Unretained(this)));
+
+    // Because the test cases only involve the main frame in this test,
+    // the fake password client is only used for the main frame.
+    content::AssociatedInterfaceProvider* remote_associated_interfaces =
+        view_->GetMainRenderFrame()->GetRemoteAssociatedInterfaces();
+    remote_associated_interfaces->OverrideBinderForTesting(
+        mojom::PasswordManagerClient::Name_,
+        base::Bind(&PasswordGenerationAgentTest::BindPasswordManagerClient,
+                   base::Unretained(this)));
   }
 
   void TearDown() override {
     LoadHTML("");
     ChromeRenderViewTest::TearDown();
   }
 
   void LoadHTMLWithUserGesture(const char* html) {
     LoadHTML(html);
 
     // Enable show-ime event when element is focused by indicating that a user
     // gesture has been processed since load.
     EXPECT_TRUE(SimulateElementClick("dummy"));
   }
 
   void FocusField(const char* element_id) {
     WebDocument document = GetMainFrame()->document();
     blink::WebElement element =
         document.getElementById(blink::WebString::fromUTF8(element_id));
     ASSERT_FALSE(element.isNull());
     ExecuteJavaScriptForTests(
         base::StringPrintf("document.getElementById('%s').focus();",
                            element_id).c_str());
   }
 
   void ExpectGenerationAvailable(const char* element_id,
                                  bool available) {
     FocusField(element_id);
-    const IPC::Message* message =
-        render_thread_->sink().GetFirstMessageMatching(
-            AutofillHostMsg_ShowPasswordGenerationPopup::ID);
+    base::RunLoop().RunUntilIdle();
+    fake_pw_client_.Flush();
+    bool called = fake_pw_client_.called_show_pw_generation_popup();
     if (available)
-      ASSERT_TRUE(message);
+      ASSERT_TRUE(called);
     else
-      ASSERT_FALSE(message);
+      ASSERT_FALSE(called);
 
-    render_thread_->sink().ClearMessages();
+    fake_pw_client_.reset_called_show_pw_generation_popup();
   }
 
   void AllowToRunFormClassifier() {
     password_generation_->AllowToRunFormClassifier();
   }
 
   void ExpectFormClassifierVoteReceived(
       bool received,
       const base::string16& expected_generation_element) {
     base::RunLoop().RunUntilIdle();
     if (received) {
       ASSERT_TRUE(fake_driver_.called_save_generation_field());
       EXPECT_EQ(expected_generation_element,
                 fake_driver_.save_generation_field());
     } else {
       ASSERT_FALSE(fake_driver_.called_save_generation_field());
     }
 
     fake_driver_.reset_save_generation_field();
   }
 
+  bool GetCalledShowPasswordGenerationPopup() {
+    fake_pw_client_.Flush();
+    return fake_pw_client_.called_show_pw_generation_popup();
+  }
+
   void ShowGenerationPopUpManually(const char* element_id) {
     FocusField(element_id);
     password_generation_->UserTriggeredGeneratePassword();
   }
 
   void BindPasswordManagerDriver(mojo::ScopedMessagePipeHandle handle) {
     fake_driver_.BindRequest(
         mojo::MakeRequest<mojom::PasswordManagerDriver>(std::move(handle)));
   }
 
+  void BindPasswordManagerClient(mojo::ScopedInterfaceEndpointHandle handle) {
+    fake_pw_client_.BindRequest(
+        mojo::MakeAssociatedRequest<mojom::PasswordManagerClient>(
+            std::move(handle)));
+  }
+
   FakeContentPasswordManagerDriver fake_driver_;
+  FakePasswordManagerClient fake_pw_client_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PasswordGenerationAgentTest);
 };
 
 const char kSigninFormHTML[] =
     "<FORM name = 'blah' action = 'http://www.random.com/'> "
     "  <INPUT type = 'text' id = 'username'/> "
     "  <INPUT type = 'password' id = 'password'/> "
     "  <INPUT type = 'button' id = 'dummy'/> "
@@ skipping 227 matching lines @@
   EXPECT_EQ(password, second_password_element.value());
 
   // After editing the first field they are still the same.
   std::string edited_password_ascii = "edited_password";
   SimulateUserInputChangeForElement(&first_password_element,
                                     edited_password_ascii);
   base::string16 edited_password = base::ASCIIToUTF16(edited_password_ascii);
   EXPECT_EQ(edited_password, first_password_element.value());
   EXPECT_EQ(edited_password, second_password_element.value());
 
-  // Clear any uninteresting sent messages.
-  render_thread_->sink().ClearMessages();
   fake_driver_.reset_called_password_no_longer_generated();
 
   // Verify that password mirroring works correctly even when the password
   // is deleted.
   SimulateUserInputChangeForElement(&first_password_element, std::string());
   EXPECT_EQ(base::string16(), first_password_element.value());
   EXPECT_EQ(base::string16(), second_password_element.value());
 
   // Should have notified the browser that the password is no longer generated
   // and trigger generation again.
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(fake_driver_.called_password_no_longer_generated());
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordGenerationPopup::ID));
+  EXPECT_TRUE(GetCalledShowPasswordGenerationPopup());
 }
 
 TEST_F(PasswordGenerationAgentTest, BlacklistedTest) {
   // Did not receive not blacklisted message. Don't show password generation
   // icon.
   LoadHTMLWithUserGesture(kAccountCreationFormHTML);
   SetAccountCreationFormsDetectedMessage(password_generation_,
                                          GetMainFrame()->document(), 0, 1);
   ExpectGenerationAvailable("first_password", false);
 
@@ skipping 52 matching lines @@
   WebElement element =
       document.getElementById(WebString::fromUTF8("first_password"));
   ASSERT_FALSE(element.isNull());
   WebInputElement first_password_element = element.to<WebInputElement>();
 
   // Make a password just under maximum offer size.
   SimulateUserInputChangeForElement(
       &first_password_element,
       std::string(password_generation_->kMaximumOfferSize - 1, 'a'));
   // There should now be a message to show the UI.
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordGenerationPopup::ID));
-  render_thread_->sink().ClearMessages();
+  EXPECT_TRUE(GetCalledShowPasswordGenerationPopup());
+  fake_pw_client_.reset_called_show_pw_generation_popup();
 
+  fake_pw_client_.reset_called_hide_pw_generation_popup();
   // Simulate a user typing a password just over maximum offer size.
   SimulateUserTypingASCIICharacter('a', false);
   SimulateUserTypingASCIICharacter('a', true);
   // There should now be a message to hide the UI.
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_HidePasswordGenerationPopup::ID));
-  render_thread_->sink().ClearMessages();
+  fake_pw_client_.Flush();
+  EXPECT_TRUE(fake_pw_client_.called_hide_pw_generation_popup());
+  fake_pw_client_.reset_called_show_pw_generation_popup();
 
   // Simulate the user deleting characters. The generation popup should be shown
   // again.
   SimulateUserTypingASCIICharacter(ui::VKEY_BACK, true);
   // There should now be a message to show the UI.
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordGenerationPopup::ID));
-  render_thread_->sink().ClearMessages();
+  EXPECT_TRUE(GetCalledShowPasswordGenerationPopup());
+  fake_pw_client_.reset_called_show_pw_generation_popup();
 
   // Change focus. Bubble should be hidden, but that is handled by AutofilAgent,
   // so no messages are sent.
   ExecuteJavaScriptForTests("document.getElementById('username').focus();");
-  EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordGenerationPopup::ID));
-  render_thread_->sink().ClearMessages();
+  EXPECT_FALSE(GetCalledShowPasswordGenerationPopup());
+  fake_pw_client_.reset_called_show_pw_generation_popup();
 
   // Focusing the password field will bring up the generation UI again.
   ExecuteJavaScriptForTests(
       "document.getElementById('first_password').focus();");
-  EXPECT_TRUE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordGenerationPopup::ID));
-  render_thread_->sink().ClearMessages();
+  EXPECT_TRUE(GetCalledShowPasswordGenerationPopup());
+  fake_pw_client_.reset_called_show_pw_generation_popup();
 
   // Loading a different page triggers UMA stat upload. Verify that only one
   // display event is sent even though
   LoadHTMLWithUserGesture(kSigninFormHTML);
 
   histogram_tester.ExpectBucketCount(
       "PasswordGeneration.Event",
       autofill::password_generation::GENERATION_POPUP_SHOWN,
       1);
 }
@@ skipping 61 matching lines @@
   // correctly (generation should still be available).
   SetNotBlacklistedMessage(password_generation_, kAccountCreationFormHTML);
 
   // Need to focus another field first for verification to work.
   ExpectGenerationAvailable("second_password", false);
   ExpectGenerationAvailable("first_password", true);
 }
 
 // Losing focus should not trigger a password generation popup.
 TEST_F(PasswordGenerationAgentTest, BlurTest) {
-  render_thread_->sink().ClearMessages();
   LoadHTMLWithUserGesture(kDisabledElementAccountCreationFormHTML);
   SetNotBlacklistedMessage(password_generation_,
                            kDisabledElementAccountCreationFormHTML);
   SetAccountCreationFormsDetectedMessage(password_generation_,
                                          GetMainFrame()->document(), 0, 1);
 
   // Focus on the first password field: password generation popup should show
   // up.
   ExpectGenerationAvailable("first_password", true);
 
+  fake_pw_client_.reset_called_generation_available_for_form();
   // Remove focus from everywhere by clicking an unfocusable element: password
   // generation popup should not show up.
   EXPECT_TRUE(SimulateElementClick("disabled"));
-  EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_GenerationAvailableForForm::ID));
-  EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
-      AutofillHostMsg_ShowPasswordGenerationPopup::ID));
+  fake_pw_client_.Flush();
+  EXPECT_FALSE(fake_pw_client_.called_generation_available_for_form());
+  EXPECT_FALSE(GetCalledShowPasswordGenerationPopup());
 }
 
 TEST_F(PasswordGenerationAgentTest, AutocompleteAttributesTest) {
   // Verify that autocomplete attributes can override Autofill to enable
   // generation
   LoadHTMLWithUserGesture(kBothAutocompleteAttributesFormHTML);
   SetNotBlacklistedMessage(password_generation_,
                            kBothAutocompleteAttributesFormHTML);
 
   ExpectGenerationAvailable("first_password", true);
@@ skipping 102 matching lines @@
                                    base::string16());
 }
 
 TEST_F(PasswordGenerationAgentTest, FormClassifierDisabled) {
   LoadHTMLWithUserGesture(kSigninFormHTML);
   ExpectFormClassifierVoteReceived(false /* vote is not expected */,
                                    base::string16());
 }
 
 }  // namespace autofill