[Password Manager] Unfriend PasswordAutofillAgentTest from PasswordAutofillAgent (clean-up).

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 "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.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"
@@ skipping 159 matching lines @@
  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, fill_data);
-    password_autofill_->OnMessageReceived(msg);
+    static_cast<content::RenderViewObserver*>(password_autofill_agent_)
+        ->OnMessageReceived(msg);
   }
 
   void SendVisiblePasswordForms() {
-    password_autofill_->SendPasswordForms(GetMainFrame(),
-                                          true /* only_visible */);
+    static_cast<content::RenderViewObserver*>(password_autofill_agent_)
+        ->DidFinishLoad(GetMainFrame());
   }
 
   virtual void SetUp() {
     ChromeRenderViewTest::SetUp();
 
     // Add a preferred login and an additional login to the FillData.
     username1_ = ASCIIToUTF16(kAliceUsername);
     password1_ = ASCIIToUTF16(kAlicePassword);
     username2_ = ASCIIToUTF16(kBobUsername);
     password2_ = ASCIIToUTF16(kBobPassword);
@@ skipping 59 matching lines @@
   }
 
   void ClearUsernameAndPasswordFields() {
     username_element_.setValue("");
     username_element_.setAutofilled(false);
     password_element_.setValue("");
     password_element_.setAutofilled(false);
   }
 
   void SimulateDidEndEditing(WebFrame* input_frame, WebInputElement& input) {
-    autofill_agent_->textFieldDidEndEditing(input);
+    static_cast<blink::WebAutofillClient*>(autofill_agent_)
+        ->textFieldDidEndEditing(input);
   }
 
   void SimulateInputChangeForElement(const std::string& new_value,
                                      bool move_caret_to_end,
                                      WebFrame* input_frame,
                                      WebInputElement& input,
                                      bool is_user_input) {
     input.setValue(WebString::fromUTF8(new_value), is_user_input);
     // The field must have focus or AutofillAgent will think the
     // change should be ignored.
     while (!input.focused())
       input_frame->document().frame()->view()->advanceFocus(false);
     if (move_caret_to_end)
       input.setSelectionRange(new_value.length(), new_value.length());
     if (is_user_input)
-      password_autofill_agent()->FirstUserGestureObserved();
-    autofill_agent_->textFieldDidChange(input);
+      password_autofill_agent_->FirstUserGestureObserved();
+    static_cast<blink::WebAutofillClient*>(autofill_agent_)
+        ->textFieldDidChange(input);
     // Processing is delayed because of a Blink bug:
     // https://bugs.webkit.org/show_bug.cgi?id=16976
     // See PasswordAutofillAgent::TextDidChangeInTextField() for details.
 
     // Autocomplete will trigger a style recalculation when we put up the next
     // frame, but we don't want to wait that long. Instead, trigger a style
     // recalcuation manually after TextFieldDidChangeImpl runs.
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &PasswordAutofillAgentTest::LayoutMainFrame, base::Unretained(this)));
 
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void SimulateSuggestionChoice(WebInputElement& username_input) {
-    blink::WebString blink_username =
-        blink::WebString::fromUTF8(kAliceUsername);
-    blink::WebString blink_password =
-        blink::WebString::fromUTF8(kAlicePassword);
+    base::string16 username(base::ASCIIToUTF16(kAliceUsername));
+    base::string16 password(base::ASCIIToUTF16(kAlicePassword));
 
     // This call is necessary to setup the autofill agent appropriate for the
     // user selection; simulates the menu actually popping up.
     render_thread_->sink().ClearMessages();
-    autofill_agent_->FormControlElementClicked(username_input, false);
+    static_cast<autofill::PageClickListener*>(autofill_agent_)
+        ->FormControlElementClicked(username_input, false);
 
-    autofill_agent_->OnFillPasswordSuggestion(blink_username, blink_password);
+    AutofillMsg_FillPasswordSuggestion msg(0, username, password);
+    static_cast<content::RenderViewObserver*>(autofill_agent_)
+        ->OnMessageReceived(msg);
   }
 
   void LayoutMainFrame() {
     GetMainFrame()->view()->layout();
   }
 
   void SimulateUsernameChange(const std::string& username,
                               bool move_caret_to_end,
                               bool is_user_input = false) {
     SimulateInputChangeForElement(username,
@@ skipping 20 matching lines @@
     // sent to the browser on acceptance, and the DCHECK isn't hit (and nothing
     // is filled).
     //
     // These tests only make sense in the context of not ignoring
     // autocomplete='off', so only test them if the disable autocomplete='off'
     // flag is not enabled.
     // TODO(jww): Remove this function and callers once autocomplete='off' is
     // permanently ignored.
     if (!ShouldIgnoreAutocompleteOffForPasswordFields()) {
       EXPECT_TRUE(
-          password_autofill_agent()->ShowSuggestions(username_element_, false));
+          password_autofill_agent_->ShowSuggestions(username_element_, false));
 
       EXPECT_FALSE(render_thread_->sink().GetFirstMessageMatching(
           AutofillHostMsg_ShowPasswordSuggestions::ID));
     }
   }
 
   void SimulateKeyDownEvent(const WebInputElement& element,
                             ui::KeyboardCode key_code) {
     blink::WebKeyboardEvent key_event;
     key_event.windowsKeyCode = key_code;
-    autofill_agent_->textFieldDidReceiveKeyDown(element, key_event);
+    static_cast<blink::WebAutofillClient*>(autofill_agent_)
+        ->textFieldDidReceiveKeyDown(element, key_event);
   }
 
   void CheckTextFieldsStateForElements(const WebInputElement& username_element,
                                        const std::string& username,
                                        bool username_autofilled,
                                        const WebInputElement& password_element,
                                        const std::string& password,
                                        bool password_autofilled,
                                        bool checkSuggestedValue) {
     EXPECT_EQ(username,
@@ skipping 80 matching lines @@
       EXPECT_TRUE(it != usernames.end());
       if (it != usernames.end())
         usernames.erase(it);
     }
 
     EXPECT_TRUE(usernames.empty());
 
     render_thread_->sink().ClearMessages();
   }
 
-  PasswordAutofillAgent* password_autofill_agent() {
-    return autofill_agent_->password_autofill_agent_;
-  }
-
   void ExpectFormSubmittedWithPasswords(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);
     Tuple1<autofill::PasswordForm> args;
     AutofillHostMsg_PasswordFormSubmitted::Read(message, &args);
     EXPECT_EQ(ASCIIToUTF16(password_value), args.a.password_value);
     EXPECT_EQ(ASCIIToUTF16(new_password_value), args.a.new_password_value);
@@ skipping 244 matching lines @@
   SimulateUsernameChange("a", true);
   CheckTextFieldsState("a", false, std::string(), false);
   SimulateUsernameChange("al", true);
   CheckTextFieldsState("al", false, std::string(), false);
   SimulateUsernameChange(kAliceUsername, true);
   CheckTextFieldsState(kAliceUsername, false, std::string(), false);
 
   // Autocomplete should happen only when the username textfield is blurred with
   // a full match.
   username_element_.setValue("a");
-  autofill_agent_->textFieldDidEndEditing(username_element_);
+  static_cast<blink::WebAutofillClient*>(autofill_agent_)
+      ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("a", false, std::string(), false);
   username_element_.setValue("al");
-  autofill_agent_->textFieldDidEndEditing(username_element_);
+  static_cast<blink::WebAutofillClient*>(autofill_agent_)
+      ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("al", false, std::string(), false);
   username_element_.setValue("alices");
-  autofill_agent_->textFieldDidEndEditing(username_element_);
+  static_cast<blink::WebAutofillClient*>(autofill_agent_)
+      ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState("alices", false, std::string(), false);
   username_element_.setValue(ASCIIToUTF16(kAliceUsername));
-  autofill_agent_->textFieldDidEndEditing(username_element_);
+  static_cast<blink::WebAutofillClient*>(autofill_agent_)
+      ->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 }
 
 // Tests that inline autocompletion works properly.
 TEST_F(PasswordAutofillAgentTest, InlineAutocomplete) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   ClearUsernameAndPasswordFields();
 
@@ skipping 250 matching lines @@
 
 // Regression test for http://crbug.com/326679
 TEST_F(PasswordAutofillAgentTest, SelectUsernameWithPasswordAutofillOff) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Set the main password element to autocomplete='off'
   password_element_.setAttribute(WebString::fromUTF8("autocomplete"),
                                  WebString::fromUTF8("off"));
 
- // Simulate the user changing the username to some known username.
+  // Simulate the user changing the username to some known username.
   SimulateUsernameChange(kAliceUsername, true);
 
   ExpectNoSuggestionsPopup();
 }
 
 // Regression test for http://crbug.com/326679
 TEST_F(PasswordAutofillAgentTest,
        SelectUnknownUsernameWithPasswordAutofillOff) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
@@ skipping 106 matching lines @@
   // Simulate the browser sending the login info, but set |wait_for_username|
   // to prevent the form from being immediately filled.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   // Neither field should have been autocompleted.
   CheckTextFieldsDOMState(std::string(), false, std::string(), false);
 
   // If the password field is not autocompletable, it should not be affected.
   SetElementReadOnly(password_element_, true);
-  EXPECT_FALSE(password_autofill_->FillSuggestion(
+  EXPECT_FALSE(password_autofill_agent_->FillSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
   CheckTextFieldsDOMState(std::string(), false, std::string(), false);
   SetElementReadOnly(password_element_, false);
 
   // After filling with the suggestion, both fields should be autocompleted.
-  EXPECT_TRUE(password_autofill_->FillSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->FillSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
   CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
   int username_length = strlen(kAliceUsername);
   CheckUsernameSelection(username_length, username_length);
 
   // Try Filling with a suggestion with password different from the one that was
   // initially sent to the renderer.
-  EXPECT_TRUE(password_autofill_->FillSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->FillSuggestion(
       username_element_, kBobUsername, kCarolPassword));
   CheckTextFieldsDOMState(kBobUsername, true, kCarolPassword, true);
   username_length = strlen(kBobUsername);
   CheckUsernameSelection(username_length, username_length);
 }
 
 // Tests that |PreviewSuggestion| properly previews the username and password.
 TEST_F(PasswordAutofillAgentTest, PreviewSuggestion) {
   // Simulate the browser sending the login info, but set |wait_for_username|
   // to prevent the form from being immediately filled.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   // Neither field should have been autocompleted.
   CheckTextFieldsDOMState(std::string(), false, std::string(), false);
 
   // If the password field is not autocompletable, it should not be affected.
   SetElementReadOnly(password_element_, true);
-  EXPECT_FALSE(password_autofill_->PreviewSuggestion(
+  EXPECT_FALSE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
   EXPECT_EQ(std::string(), username_element_.suggestedValue().utf8());
   EXPECT_FALSE(username_element_.isAutofilled());
   EXPECT_EQ(std::string(), password_element_.suggestedValue().utf8());
   EXPECT_FALSE(password_element_.isAutofilled());
   SetElementReadOnly(password_element_, false);
 
   // After selecting the suggestion, both fields should be previewed
   // with suggested values.
-  EXPECT_TRUE(password_autofill_->PreviewSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
   EXPECT_EQ(
       kAliceUsername,
       static_cast<std::string>(username_element_.suggestedValue().utf8()));
   EXPECT_TRUE(username_element_.isAutofilled());
   EXPECT_EQ(
       kAlicePassword,
       static_cast<std::string>(password_element_.suggestedValue().utf8()));
   EXPECT_TRUE(password_element_.isAutofilled());
   int username_length = strlen(kAliceUsername);
   CheckUsernameSelection(0, username_length);
 
   // Try previewing with a password different from the one that was initially
   // sent to the renderer.
-  EXPECT_TRUE(password_autofill_->PreviewSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kBobUsername, kCarolPassword));
   EXPECT_EQ(
       kBobUsername,
       static_cast<std::string>(username_element_.suggestedValue().utf8()));
   EXPECT_TRUE(username_element_.isAutofilled());
   EXPECT_EQ(
       kCarolPassword,
       static_cast<std::string>(password_element_.suggestedValue().utf8()));
   EXPECT_TRUE(password_element_.isAutofilled());
   username_length = strlen(kBobUsername);
   CheckUsernameSelection(0, username_length);
 }
 
 // Tests that |PreviewSuggestion| properly sets the username selection range.
 TEST_F(PasswordAutofillAgentTest, PreviewSuggestionSelectionRange) {
   username_element_.setValue(WebString::fromUTF8("ali"));
   username_element_.setSelectionRange(3, 3);
   username_element_.setAutofilled(true);
 
   CheckTextFieldsDOMState("ali", true, std::string(), false);
 
   // Simulate the browser sending the login info, but set |wait_for_username|
   // to prevent the form from being immediately filled.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
-  EXPECT_TRUE(password_autofill_->PreviewSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
   EXPECT_EQ(
       kAliceUsername,
       static_cast<std::string>(username_element_.suggestedValue().utf8()));
   EXPECT_TRUE(username_element_.isAutofilled());
   EXPECT_EQ(
       kAlicePassword,
       static_cast<std::string>(password_element_.suggestedValue().utf8()));
   EXPECT_TRUE(password_element_.isAutofilled());
   int username_length = strlen(kAliceUsername);
   CheckUsernameSelection(3, username_length);
 }
 
 // Tests that |ClearPreview| properly clears previewed username and password
 // with password being previously autofilled.
 TEST_F(PasswordAutofillAgentTest, ClearPreviewWithPasswordAutofilled) {
   password_element_.setValue(WebString::fromUTF8("sec"));
   password_element_.setAutofilled(true);
 
   // Simulate the browser sending the login info, but set |wait_for_username|
   // to prevent the form from being immediately filled.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   CheckTextFieldsDOMState(std::string(), false, "sec", true);
 
-  EXPECT_TRUE(password_autofill_->PreviewSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
 
-  EXPECT_TRUE(password_autofill_->DidClearAutofillSelection(
-      username_element_));
+  EXPECT_TRUE(
+      password_autofill_agent_->DidClearAutofillSelection(username_element_));
 
   EXPECT_TRUE(username_element_.value().isEmpty());
   EXPECT_TRUE(username_element_.suggestedValue().isEmpty());
   EXPECT_FALSE(username_element_.isAutofilled());
   EXPECT_EQ(ASCIIToUTF16("sec"), password_element_.value());
   EXPECT_TRUE(password_element_.suggestedValue().isEmpty());
   EXPECT_TRUE(password_element_.isAutofilled());
   CheckUsernameSelection(0, 0);
 }
 
 // Tests that |ClearPreview| properly clears previewed username and password
 // with username being previously autofilled.
 TEST_F(PasswordAutofillAgentTest, ClearPreviewWithUsernameAutofilled) {
   username_element_.setValue(WebString::fromUTF8("ali"));
   username_element_.setSelectionRange(3, 3);
   username_element_.setAutofilled(true);
 
   // Simulate the browser sending the login info, but set |wait_for_username|
   // to prevent the form from being immediately filled.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   CheckTextFieldsDOMState("ali", true, std::string(), false);
 
-  EXPECT_TRUE(password_autofill_->PreviewSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
 
-  EXPECT_TRUE(password_autofill_->DidClearAutofillSelection(
-      username_element_));
+  EXPECT_TRUE(
+      password_autofill_agent_->DidClearAutofillSelection(username_element_));
 
   EXPECT_EQ(ASCIIToUTF16("ali"), username_element_.value());
   EXPECT_TRUE(username_element_.suggestedValue().isEmpty());
   EXPECT_TRUE(username_element_.isAutofilled());
   EXPECT_TRUE(password_element_.value().isEmpty());
   EXPECT_TRUE(password_element_.suggestedValue().isEmpty());
   EXPECT_FALSE(password_element_.isAutofilled());
   CheckUsernameSelection(3, 3);
 }
 
 // Tests that |ClearPreview| properly clears previewed username and password
 // with username and password being previously autofilled.
 TEST_F(PasswordAutofillAgentTest,
        ClearPreviewWithAutofilledUsernameAndPassword) {
   username_element_.setValue(WebString::fromUTF8("ali"));
   username_element_.setSelectionRange(3, 3);
   username_element_.setAutofilled(true);
   password_element_.setValue(WebString::fromUTF8("sec"));
   password_element_.setAutofilled(true);
 
   // Simulate the browser sending the login info, but set |wait_for_username|
   // to prevent the form from being immediately filled.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   CheckTextFieldsDOMState("ali", true, "sec", true);
 
-  EXPECT_TRUE(password_autofill_->PreviewSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
 
-  EXPECT_TRUE(password_autofill_->DidClearAutofillSelection(
-      username_element_));
+  EXPECT_TRUE(
+      password_autofill_agent_->DidClearAutofillSelection(username_element_));
 
   EXPECT_EQ(ASCIIToUTF16("ali"), username_element_.value());
   EXPECT_TRUE(username_element_.suggestedValue().isEmpty());
   EXPECT_TRUE(username_element_.isAutofilled());
   EXPECT_EQ(ASCIIToUTF16("sec"), password_element_.value());
   EXPECT_TRUE(password_element_.suggestedValue().isEmpty());
   EXPECT_TRUE(password_element_.isAutofilled());
   CheckUsernameSelection(3, 3);
 }
 
 // Tests that |ClearPreview| properly clears previewed username and password
 // with neither username nor password being previously autofilled.
 TEST_F(PasswordAutofillAgentTest,
        ClearPreviewWithNotAutofilledUsernameAndPassword) {
   // Simulate the browser sending the login info, but set |wait_for_username|
   // to prevent the form from being immediately filled.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   CheckTextFieldsDOMState(std::string(), false, std::string(), false);
 
-  EXPECT_TRUE(password_autofill_->PreviewSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, kAliceUsername, kAlicePassword));
 
-  EXPECT_TRUE(password_autofill_->DidClearAutofillSelection(
-      username_element_));
+  EXPECT_TRUE(
+      password_autofill_agent_->DidClearAutofillSelection(username_element_));
 
   EXPECT_TRUE(username_element_.value().isEmpty());
   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 |ClearPreview| properly restores the original selection range of
 // username field that has initially been filled by inline autocomplete.
 TEST_F(PasswordAutofillAgentTest, ClearPreviewWithInlineAutocompletedUsername) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
 
   // Simulate the user typing in the first letter of 'alice', a stored username.
   SimulateUsernameChange("a", true);
   // Both the username and password text fields should reflect selection of the
   // stored login.
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
   // The selection should have been set to 'lice', the last 4 letters.
   CheckUsernameSelection(1, 5);
 
-  EXPECT_TRUE(password_autofill_->PreviewSuggestion(
+  EXPECT_TRUE(password_autofill_agent_->PreviewSuggestion(
       username_element_, "alicia", "secret"));
   EXPECT_EQ(
       "alicia",
       static_cast<std::string>(username_element_.suggestedValue().utf8()));
   EXPECT_TRUE(username_element_.isAutofilled());
   EXPECT_EQ(
       "secret",
       static_cast<std::string>(password_element_.suggestedValue().utf8()));
   EXPECT_TRUE(password_element_.isAutofilled());
   CheckUsernameSelection(1, 6);
 
-  EXPECT_TRUE(password_autofill_->DidClearAutofillSelection(
-      username_element_));
+  EXPECT_TRUE(
+      password_autofill_agent_->DidClearAutofillSelection(username_element_));
 
   EXPECT_EQ(kAliceUsername, username_element_.value().utf8());
   EXPECT_TRUE(username_element_.suggestedValue().isEmpty());
   EXPECT_TRUE(username_element_.isAutofilled());
   EXPECT_TRUE(password_element_.value().isEmpty());
   EXPECT_TRUE(password_element_.suggestedValue().isEmpty());
   EXPECT_TRUE(password_element_.isAutofilled());
   CheckUsernameSelection(1, 5);
 }
 
 // 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);
 }
 
 // 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_)
+  EXPECT_TRUE(static_cast<IPC::Listener*>(password_autofill_agent_)
                   ->OnMessageReceived(msg_activate));
 
   render_thread_->sink().ClearMessages();
   SendVisiblePasswordForms();
   const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_RecordSavePasswordProgress::ID);
   EXPECT_TRUE(message);
 }
 
 // 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_)
+  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_)
+  EXPECT_TRUE(static_cast<IPC::Listener*>(password_autofill_agent_)
                   ->OnMessageReceived(msg_deactivate));
 
   render_thread_->sink().ClearMessages();
   SendVisiblePasswordForms();
   const IPC::Message* message = render_thread_->sink().GetFirstMessageMatching(
       AutofillHostMsg_RecordSavePasswordProgress::ID);
   EXPECT_FALSE(message);
 }
 
 // Test that the agent sends an IPC call to get the current activity state of
@@ skipping 34 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();
-  autofill_agent_->FormControlElementClicked(username_element_, false);
+  static_cast<PageClickListener*>(autofill_agent_)
+      ->FormControlElementClicked(username_element_, false);
   ExpectAllCredentials();
 
   // 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", true);
   render_thread_->sink().ClearMessages();
-  autofill_agent_->FormControlElementClicked(username_element_, true);
+  static_cast<PageClickListener*>(autofill_agent_)
+      ->FormControlElementClicked(username_element_, true);
   ExpectAllCredentials();
 
   // Now simulate a user typing in the first letter of the username and then
   // clicking on the username element. While the typing of the first letter will
   // inline autocomplete, clicking on the element should still produce a full
   // suggestion list.
   SimulateUsernameChange("a", true);
   render_thread_->sink().ClearMessages();
-  autofill_agent_->FormControlElementClicked(username_element_, true);
+  static_cast<PageClickListener*>(autofill_agent_)
+      ->FormControlElementClicked(username_element_, true);
   ExpectAllCredentials();
 }
 
 // The user types in a password, but then just before sending the form off, a
 // script clears that password. This test checks that PasswordAutofillAgent can
 // still remember the password typed by the user.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyPasswordOnSubmit_ScriptCleared) {
   SimulateInputChangeForElement(
       "temp", true, GetMainFrame(), username_element_, true);
   SimulateInputChangeForElement(
       "random", true, GetMainFrame(), password_element_, true);
 
   // Simulate that the password value was cleared by the site's JavaScript
   // before submit.
   password_element_.setValue(WebString());
-  static_cast<content::RenderViewObserver*>(password_autofill_agent())
+  static_cast<content::RenderViewObserver*>(password_autofill_agent_)
       ->WillSubmitForm(GetMainFrame(), username_element_.form());
 
   // Observe that the PasswordAutofillAgent still remembered the last non-empty
   // password and sent that to the browser.
   ExpectFormSubmittedWithPasswords("random", "");
 }
 
 // Similar to RememberLastNonEmptyPasswordOnSubmit_ScriptCleared, but this time
 // it's the user who clears the password. This test checks that in that case,
 // the last non-empty password is not remembered.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyPasswordOnSubmit_UserCleared) {
   SimulateInputChangeForElement(
       "temp", true, GetMainFrame(), username_element_, true);
   SimulateInputChangeForElement(
       "random", true, GetMainFrame(), password_element_, true);
 
   // Simulate that the user actually cleared the password again.
   SimulateInputChangeForElement(
       "", true, GetMainFrame(), password_element_, true);
-  static_cast<content::RenderViewObserver*>(password_autofill_agent())
+  static_cast<content::RenderViewObserver*>(password_autofill_agent_)
       ->WillSubmitForm(GetMainFrame(), username_element_.form());
 
   // Observe that the PasswordAutofillAgent respects the user having cleared the
   // password.
   ExpectFormSubmittedWithPasswords("", "");
 }
 
 // Similar to RememberLastNonEmptyPasswordOnSubmit_ScriptCleared, but uses the
 // new password instead of the current password.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyPasswordOnSubmit_NewPassword) {
   const char kNewPasswordFormHTML[] =
       "<FORM name='LoginTestForm'>"
       "  <INPUT type='text' id='username' autocomplete='username'/>"
       "  <INPUT type='password' id='password' autocomplete='new-password'/>"
       "  <INPUT type='submit' value='Login'/>"
       "</FORM>";
   LoadHTML(kNewPasswordFormHTML);
   UpdateUsernameAndPasswordElements();
 
   SimulateInputChangeForElement(
       "temp", true, GetMainFrame(), username_element_, true);
   SimulateInputChangeForElement(
       "random", true, GetMainFrame(), password_element_, true);
 
   // Simulate that the password value was cleared by the site's JavaScript
   // before submit.
   password_element_.setValue(WebString());
-  static_cast<content::RenderViewObserver*>(password_autofill_agent())
+  static_cast<content::RenderViewObserver*>(password_autofill_agent_)
       ->WillSubmitForm(GetMainFrame(), username_element_.form());
 
   // Observe that the PasswordAutofillAgent still remembered the last non-empty
   // password and sent that to the browser.
   ExpectFormSubmittedWithPasswords("", "random");
 }
 
 // The user first accepts a suggestion, but then overwrites the password. This
 // test checks that the overwritten password is not reverted back if the user
 // triggers autofill through focusing (but not changing) the username again.
@@ skipping 46 matching lines @@
                                 password_element_,
                                 /*is_user_input=*/true);
 
   // Simulate the user typing a stored username.
   SimulateUsernameChange(kAliceUsername, true);
   // The autofileld password should replace the typed one.
   CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
 }
 
 }  // namespace autofill