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);
+    }
+    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 523 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 23 matching lines @@
 
   // The username and password should have been autocompleted.
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 
   // However, it should only have completed with the suggested value, as tested
   // above, and it should not have completed into the DOM accessible value for
   // the password field.
   CheckTextFieldsDOMState(kAliceUsername, true, std::string(), true);
 
   // Simulate a user click so that the password field's real value is filled.
-  SimulateElementClick(kUsernameName);
+  password_autofill_agent_->FirstUserGestureObserved();

[vabr (Chromium), 2014/11/25 15:56:57]

This is decreasing the scope of the test: before it tested that if the page gets
clicked, password values appear. Not it tests that if the agent is told that
there has been a click, the passwords appear. Do you have a good suggestion
where to check the part between the click and the FirstUserGestureObserved()
call?

[Evan Stade, 2014/11/25 21:07:40]

turns out I can revert this.

   CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
 }
 
 // Verfies that a DOM-activated UI event will not cause an autofill.
 TEST_F(PasswordAutofillAgentTest, NoDOMActivationTest) {
   // Trigger the initial autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   ExecuteJavaScript(kJavaScriptClick);
   CheckTextFieldsDOMState(kAliceUsername, true, "", true);
@@ skipping 28 matching lines @@
           &username_onchange_called));
   EXPECT_EQ(1, username_onchange_called);
   ASSERT_TRUE(
       ExecuteJavaScriptAndReturnIntValue(
           ASCIIToUTF16("passwordOnchangeCalled ? 1 : 0"),
           &password_onchange_called));
   // TODO(isherman): Re-enable this check once http://crbug.com/333144 is fixed.
   // EXPECT_EQ(0, password_onchange_called);
 
   // Simulate a user click so that the password field's real value is filled.
-  SimulateElementClick(kUsernameName);
+  password_autofill_agent_->FirstUserGestureObserved();
   CheckTextFieldsDOMState(kAliceUsername, true, kAlicePassword, true);
 
   // Now, a JavaScript onChange event should have been triggered for the
   // password as well.
   ASSERT_TRUE(
       ExecuteJavaScriptAndReturnIntValue(
           ASCIIToUTF16("passwordOnchangeCalled ? 1 : 0"),
           &password_onchange_called));
   EXPECT_EQ(1, password_onchange_called);
 }
@@ skipping 432 matching lines @@
 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_->legacy_)
       ->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_->legacy_)
       ->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_->legacy_)
       ->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 33 matching lines @@
 }
 
 TEST_F(PasswordAutofillAgentTest,
        InlineAutocompleteOverwritesManuallyEditedPassword) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   ClearUsernameAndPasswordFields();
 
   // The user enters a password
+  password_autofill_agent_->FirstUserGestureObserved();

[vabr (Chromium), 2014/11/25 15:56:57]

Why is this needed? User-entered passwords should not be blocked by the
gesture-based gatekeeper. (And the very first line of
SimulateInputChangeForElement seems to directly set the value.)

[Evan Stade, 2014/11/25 21:07:40]

Setting the value doesn't call FirstUserGestureObserved.

This line was already a part of SimulateInputChangeForElement. I've moved this
line back into that function.

   SimulateInputChangeForElement("someOtherPassword",
                                 /*move_caret_to_end=*/true,
                                 GetMainFrame(),
                                 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