Refactor Autofill for out of process iframes (OOPIF).

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"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/autofill/content/renderer/test_password_autofill_agent.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
+#include "content/public/renderer/render_frame.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/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"
 #include "third_party/WebKit/public/web/WebView.h"
@@ skipping 146 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, kPasswordFillFormDataId, fill_data);
-    static_cast<content::RenderViewObserver*>(password_autofill_agent_)
+    static_cast<content::RenderFrameObserver*>(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);
+  }
+
   void SendVisiblePasswordForms() {
-    static_cast<content::RenderViewObserver*>(password_autofill_agent_)
-        ->DidFinishLoad(GetMainFrame());
+    static_cast<content::RenderFrameObserver*>(password_autofill_agent_)
+        ->DidFinishLoad();
   }
 
   void SetUp() override {
     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 75 matching lines @@
                                      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();
-    static_cast<blink::WebAutofillClient*>(autofill_agent_)
-        ->textFieldDidChange(input);
+    if (is_user_input) {
+      AutofillMsg_FirstUserGestureObservedInTab msg(0);
+      content::RenderFrame::FromWebFrame(input_frame)->OnMessageReceived(msg);
+
+      // Also pass the message to the testing object.
+      if (input_frame == GetMainFrame())
+        password_autofill_agent_->FirstUserGestureObserved();
+    }
+    input_frame->toWebLocalFrame()->autofillClient()->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) {
     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();
     static_cast<autofill::PageClickListener*>(autofill_agent_)
         ->FormControlElementClicked(username_input, false);
 
     AutofillMsg_FillPasswordSuggestion msg(0, username, password);
-    static_cast<content::RenderViewObserver*>(autofill_agent_)
+    static_cast<content::RenderFrameObserver*>(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) {
@@ skipping 526 matching lines @@
   std::string page_html(kWebpageWithIframeStart);
   page_html += origin;
   page_html += kWebpageWithIframeEnd;
 
   LoadHTML(page_html.c_str());
 
   // Set the expected form origin and action URLs.
   fill_data_.origin = GURL(origin);
   fill_data_.action = GURL(origin);
 
-  SimulateOnFillPasswordForm(fill_data_);
-
   // Retrieve the input elements from the iframe since that is where we want to
   // test the autofill.
   WebFrame* iframe = GetMainFrame()->findChildByName(kIframeName);
   ASSERT_TRUE(iframe);
+
+  SimulateOnFillPasswordFormForFrame(iframe, fill_data_);
+
   WebDocument document = iframe->document();
 
   WebElement username_element = document.getElementById(kUsernameName);
   WebElement password_element = document.getElementById(kPasswordName);
   ASSERT_FALSE(username_element.isNull());
   ASSERT_FALSE(password_element.isNull());
 
   WebInputElement username_input = username_element.to<WebInputElement>();
   WebInputElement password_input = password_element.to<WebInputElement>();
   ASSERT_FALSE(username_element.isNull());
@@ skipping 527 matching lines @@
        RememberLastNonEmptyUsernameAndPasswordOnSubmit_ScriptCleared) {
   SimulateInputChangeForElement(
       "temp", true, GetMainFrame(), username_element_, true);
   SimulateInputChangeForElement(
       "random", true, GetMainFrame(), password_element_, true);
 
   // Simulate that the username and the password value was cleared by the
   // site's JavaScript before submit.
   username_element_.setValue(WebString());
   password_element_.setValue(WebString());
-  static_cast<content::RenderViewObserver*>(password_autofill_agent_)
+  static_cast<content::RenderViewObserver*>(&password_autofill_agent_->legacy_)
       ->WillSubmitForm(GetMainFrame(), username_element_.form());
 
   // Observe that the PasswordAutofillAgent still remembered the last non-empty
   // username and password and sent that to the browser.
   ExpectFormSubmittedWithUsernameAndPasswords("temp", "random", "");
 }
 
 // Similar to RememberLastNonEmptyPasswordOnSubmit_ScriptCleared, but this time
 // it's the user who clears the username and the password. This test checks
 // that in that case, the last non-empty username and password are not
 // remembered.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyUsernameAndPasswordOnSubmit_UserCleared) {
   SimulateInputChangeForElement(
       "temp", true, GetMainFrame(), username_element_, true);
   SimulateInputChangeForElement(
       "random", true, GetMainFrame(), password_element_, true);
 
   // Simulate that the user actually cleared the username and password again.
   SimulateInputChangeForElement("", true, GetMainFrame(), username_element_,
                                 true);
   SimulateInputChangeForElement(
       "", true, GetMainFrame(), password_element_, true);
-  static_cast<content::RenderViewObserver*>(password_autofill_agent_)
+  static_cast<content::RenderViewObserver*>(&password_autofill_agent_->legacy_)
       ->WillSubmitForm(GetMainFrame(), username_element_.form());
 
   // Observe that the PasswordAutofillAgent respects the user having cleared the
   // password.
   ExpectFormSubmittedWithUsernameAndPasswords("", "", "");
 }
 
 // Similar to RememberLastNonEmptyPasswordOnSubmit_ScriptCleared, but uses the
 // new password instead of the current password.
 TEST_F(PasswordAutofillAgentTest,
        RememberLastNonEmptyUsernameAndPasswordOnSubmit_New) {
   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 username and the password value was cleared by
   // the site's JavaScript before submit.
   username_element_.setValue(WebString());
   password_element_.setValue(WebString());
-  static_cast<content::RenderViewObserver*>(password_autofill_agent_)
+  static_cast<content::RenderViewObserver*>(&password_autofill_agent_->legacy_)
       ->WillSubmitForm(GetMainFrame(), username_element_.form());
 
   // Observe that the PasswordAutofillAgent still remembered the last non-empty
   // password and sent that to the browser.
   ExpectFormSubmittedWithUsernameAndPasswords("temp", "", "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