chrome/renderer/autofill/password_autofill_agent_browsertest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/strings/string_util.h"
   6 #include "base/strings/utf_string_conversions.h"
   7 #include "chrome/test/base/chrome_render_view_test.h"
   8 #include "components/autofill/content/renderer/autofill_agent.h"
   9 #include "components/autofill/content/renderer/password_autofill_agent.h"
  10 #include "components/autofill/core/common/autofill_messages.h"
  11 #include "components/autofill/core/common/form_data.h"
  12 #include "components/autofill/core/common/form_field_data.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/WebKit/public/platform/WebString.h"
  15 #include "third_party/WebKit/public/platform/WebVector.h"
  16 #include "third_party/WebKit/public/web/WebDocument.h"
  17 #include "third_party/WebKit/public/web/WebElement.h"
  18 #include "third_party/WebKit/public/web/WebFormElement.h"
  19 #include "third_party/WebKit/public/web/WebInputElement.h"
  20 #include "third_party/WebKit/public/web/WebNode.h"
  21 #include "third_party/WebKit/public/web/WebView.h"
  22 #include "ui/base/keycodes/keyboard_codes.h"
  23
  24 using content::PasswordForm;
  25 using WebKit::WebDocument;
  26 using WebKit::WebElement;
  27 using WebKit::WebFrame;
  28 using WebKit::WebInputElement;
  29 using WebKit::WebString;
  30 using WebKit::WebView;
  31
  32 namespace {
  33
  34 // The name of the username/password element in the form.
  35 const char* const kUsernameName = "username";
  36 const char* const kPasswordName = "password";
  37
  38 const char* const kAliceUsername = "alice";
  39 const char* const kAlicePassword = "password";
  40 const char* const kBobUsername = "bob";
  41 const char* const kBobPassword = "secret";
  42 const char* const kCarolUsername = "Carol";
  43 const char* const kCarolPassword = "test";
  44 const char* const kCarolAlternateUsername = "RealCarolUsername";
  45
  46
  47 const char* const kFormHTML =
  48     "<FORM name='LoginTestForm' action='http://www.bidule.com'>"
  49     "  <INPUT type='text' id='username'/>"
  50     "  <INPUT type='password' id='password'/>"
  51     "  <INPUT type='submit' value='Login'/>"
  52     "</FORM>";
  53
  54 }  // namespace
  55
  56 namespace autofill {
  57
  58 class PasswordAutofillAgentTest : public ChromeRenderViewTest {
  59  public:
  60   PasswordAutofillAgentTest() {
  61   }
  62
  63   // Simulates the fill password form message being sent to the renderer.
  64   // We use that so we don't have to make RenderView::OnFillPasswordForm()
  65   // protected.
  66   void SimulateOnFillPasswordForm(
  67       const PasswordFormFillData& fill_data) {
  68     AutofillMsg_FillPasswordForm msg(0, fill_data);
  69     password_autofill_->OnMessageReceived(msg);
  70   }
  71
  72   virtual void SetUp() {
  73     ChromeRenderViewTest::SetUp();
  74
  75     // Add a preferred login and an additional login to the FillData.
  76     username1_ = ASCIIToUTF16(kAliceUsername);
  77     password1_ = ASCIIToUTF16(kAlicePassword);
  78     username2_ = ASCIIToUTF16(kBobUsername);
  79     password2_ = ASCIIToUTF16(kBobPassword);
  80     username3_ = ASCIIToUTF16(kCarolUsername);
  81     password3_ = ASCIIToUTF16(kCarolPassword);
  82     alternate_username3_ = ASCIIToUTF16(kCarolAlternateUsername);
  83
  84     FormFieldData username_field;
  85     username_field.name = ASCIIToUTF16(kUsernameName);
  86     username_field.value = username1_;
  87     fill_data_.basic_data.fields.push_back(username_field);
  88
  89     FormFieldData password_field;
  90     password_field.name = ASCIIToUTF16(kPasswordName);
  91     password_field.value = password1_;
  92     password_field.form_control_type = "password";
  93     fill_data_.basic_data.fields.push_back(password_field);
  94
  95     PasswordAndRealm password2;
  96     password2.password = password2_;
  97     fill_data_.additional_logins[username2_] = password2;
  98     PasswordAndRealm password3;
  99     password3.password = password3_;
 100     fill_data_.additional_logins[username3_] = password3;
 101
 102     UsernamesCollectionKey key;
 103     key.username = username3_;
 104     key.password = password3_;
 105     key.realm = "google.com";
 106     fill_data_.other_possible_usernames[key].push_back(alternate_username3_);
 107
 108     // We need to set the origin so it matches the frame URL and the action so
 109     // it matches the form action, otherwise we won't autocomplete.
 110     std::string origin("data:text/html;charset=utf-8,");
 111     origin += kFormHTML;
 112     fill_data_.basic_data.origin = GURL(origin);
 113     fill_data_.basic_data.action = GURL("http://www.bidule.com");
 114
 115     LoadHTML(kFormHTML);
 116
 117     // Now retrieves the input elements so the test can access them.
 118     WebDocument document = GetMainFrame()->document();
 119     WebElement element =
 120         document.getElementById(WebString::fromUTF8(kUsernameName));
 121     ASSERT_FALSE(element.isNull());
 122     username_element_ = element.to<WebKit::WebInputElement>();
 123     element = document.getElementById(WebString::fromUTF8(kPasswordName));
 124     ASSERT_FALSE(element.isNull());
 125     password_element_ = element.to<WebKit::WebInputElement>();
 126   }
 127
 128   virtual void TearDown() {
 129     username_element_.reset();
 130     password_element_.reset();
 131     ChromeRenderViewTest::TearDown();
 132   }
 133
 134   void ClearUsernameAndPasswordFields() {
 135     username_element_.setValue("");
 136     username_element_.setAutofilled(false);
 137     password_element_.setValue("");
 138     password_element_.setAutofilled(false);
 139   }
 140
 141   void SimulateUsernameChange(const std::string& username,
 142                               bool move_caret_to_end) {
 143     username_element_.setValue(WebString::fromUTF8(username));
 144     // The field must have focus or AutofillAgent will think the
 145     // change should be ignored.
 146     while (!username_element_.focused())
 147       GetMainFrame()->document().frame()->view()->advanceFocus(false);
 148     if (move_caret_to_end)
 149       username_element_.setSelectionRange(username.length(), username.length());
 150     autofill_agent_->textFieldDidChange(username_element_);
 151     // Processing is delayed because of a WebKit bug, see
 152     // PasswordAutocompleteManager::TextDidChangeInTextField() for details.
 153     base::MessageLoop::current()->RunUntilIdle();
 154   }
 155
 156   void SimulateKeyDownEvent(const WebInputElement& element,
 157                             ui::KeyboardCode key_code) {
 158     WebKit::WebKeyboardEvent key_event;
 159     key_event.windowsKeyCode = key_code;
 160     autofill_agent_->textFieldDidReceiveKeyDown(element, key_event);
 161   }
 162
 163   void CheckTextFieldsState(const std::string& username,
 164                             bool username_autofilled,
 165                             const std::string& password,
 166                             bool password_autofilled) {
 167     EXPECT_EQ(username,
 168               static_cast<std::string>(username_element_.value().utf8()));
 169     EXPECT_EQ(username_autofilled, username_element_.isAutofilled());
 170     EXPECT_EQ(password,
 171               static_cast<std::string>(password_element_.value().utf8()));
 172     EXPECT_EQ(password_autofilled, password_element_.isAutofilled());
 173   }
 174
 175   void CheckUsernameSelection(int start, int end) {
 176     EXPECT_EQ(start, username_element_.selectionStart());
 177     EXPECT_EQ(end, username_element_.selectionEnd());
 178   }
 179
 180   string16 username1_;
 181   string16 username2_;
 182   string16 username3_;
 183   string16 password1_;
 184   string16 password2_;
 185   string16 password3_;
 186   string16 alternate_username3_;
 187   PasswordFormFillData fill_data_;
 188
 189   WebInputElement username_element_;
 190   WebInputElement password_element_;
 191
 192  private:
 193   DISALLOW_COPY_AND_ASSIGN(PasswordAutofillAgentTest);
 194 };
 195
 196 // Tests that the password login is autocompleted as expected when the browser
 197 // sends back the password info.
 198 TEST_F(PasswordAutofillAgentTest, InitialAutocomplete) {
 199   /*
 200    * Right now we are not sending the message to the browser because we are
 201    * loading a data URL and the security origin canAccessPasswordManager()
 202    * returns false.  May be we should mock URL loading to cirmcuvent this?
 203    TODO(jcivelli): find a way to make the security origin not deny access to the
 204                    password manager and then reenable this code.
 205
 206   // The form has been loaded, we should have sent the browser a message about
 207   // the form.
 208   const IPC::Message* msg = render_thread_.sink().GetFirstMessageMatching(
 209       AutofillHostMsg_PasswordFormsParsed::ID);
 210   ASSERT_TRUE(msg != NULL);
 211
 212   Tuple1<std::vector<PasswordForm> > forms;
 213   AutofillHostMsg_PasswordFormsParsed::Read(msg, &forms);
 214   ASSERT_EQ(1U, forms.a.size());
 215   PasswordForm password_form = forms.a[0];
 216   EXPECT_EQ(PasswordForm::SCHEME_HTML, password_form.scheme);
 217   EXPECT_EQ(ASCIIToUTF16(kUsernameName), password_form.username_element);
 218   EXPECT_EQ(ASCIIToUTF16(kPasswordName), password_form.password_element);
 219   */
 220
 221   // Simulate the browser sending back the login info, it triggers the
 222   // autocomplete.
 223   SimulateOnFillPasswordForm(fill_data_);
 224
 225   // The username and password should have been autocompleted.
 226   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 227 }
 228
 229 // Tests that we correctly fill forms having an empty 'action' attribute.
 230 TEST_F(PasswordAutofillAgentTest, InitialAutocompleteForEmptyAction) {
 231   const char kEmptyActionFormHTML[] =
 232       "<FORM name='LoginTestForm'>"
 233       "  <INPUT type='text' id='username'/>"
 234       "  <INPUT type='password' id='password'/>"
 235       "  <INPUT type='submit' value='Login'/>"
 236       "</FORM>";
 237   LoadHTML(kEmptyActionFormHTML);
 238
 239   // Retrieve the input elements so the test can access them.
 240   WebDocument document = GetMainFrame()->document();
 241   WebElement element =
 242       document.getElementById(WebString::fromUTF8(kUsernameName));
 243   ASSERT_FALSE(element.isNull());
 244   username_element_ = element.to<WebKit::WebInputElement>();
 245   element = document.getElementById(WebString::fromUTF8(kPasswordName));
 246   ASSERT_FALSE(element.isNull());
 247   password_element_ = element.to<WebKit::WebInputElement>();
 248
 249   // Set the expected form origin and action URLs.
 250   std::string origin("data:text/html;charset=utf-8,");
 251   origin += kEmptyActionFormHTML;
 252   fill_data_.basic_data.origin = GURL(origin);
 253   fill_data_.basic_data.action = GURL(origin);
 254
 255   // Simulate the browser sending back the login info, it triggers the
 256   // autocomplete.
 257   SimulateOnFillPasswordForm(fill_data_);
 258
 259   // The username and password should have been autocompleted.
 260   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 261 }
 262
 263 // Tests that if a password or input element is marked as readonly, neither
 264 // field is autofilled on page load.
 265 TEST_F(PasswordAutofillAgentTest, NoInitialAutocompleteForReadOnly) {
 266   password_element_.setAttribute(WebString::fromUTF8("readonly"),
 267                                  WebString::fromUTF8("true"));
 268
 269   // Simulate the browser sending back the login info, it triggers the
 270   // autocomplete.
 271   SimulateOnFillPasswordForm(fill_data_);
 272
 273   CheckTextFieldsState(std::string(), false, std::string(), false);
 274 }
 275
 276 // Tests that having a non-matching username precludes the autocomplete.
 277 TEST_F(PasswordAutofillAgentTest, NoInitialAutocompleteForFilledField) {
 278   username_element_.setValue(WebString::fromUTF8("bogus"));
 279
 280   // Simulate the browser sending back the login info, it triggers the
 281   // autocomplete.
 282   SimulateOnFillPasswordForm(fill_data_);
 283
 284   // Neither field should be autocompleted.
 285   CheckTextFieldsState("bogus", false, std::string(), false);
 286 }
 287
 288 // Tests that we do not autofill username/passwords if marked as
 289 // autocomplete="off".
 290 TEST_F(PasswordAutofillAgentTest, NoInitialAutocompleteForAutocompleteOff) {
 291   username_element_.setAttribute(WebString::fromUTF8("autocomplete"),
 292                                  WebString::fromUTF8("off"));
 293
 294   // Simulate the browser sending back the login info, it triggers the
 295   // autocomplete.
 296   SimulateOnFillPasswordForm(fill_data_);
 297
 298   CheckTextFieldsState(std::string(), false, std::string(), false);
 299 }
 300
 301 TEST_F(PasswordAutofillAgentTest, NoAutocompleteForTextFieldPasswords) {
 302   const char kTextFieldPasswordFormHTML[] =
 303       "<FORM name='LoginTestForm' action='http://www.bidule.com'>"
 304       "  <INPUT type='text' id='username'/>"
 305       "  <INPUT type='text' id='password'/>"
 306       "  <INPUT type='submit' value='Login'/>"
 307       "</FORM>";
 308   LoadHTML(kTextFieldPasswordFormHTML);
 309
 310   // Retrieve the input elements so the test can access them.
 311   WebDocument document = GetMainFrame()->document();
 312   WebElement element =
 313       document.getElementById(WebString::fromUTF8(kUsernameName));
 314   ASSERT_FALSE(element.isNull());
 315   username_element_ = element.to<WebKit::WebInputElement>();
 316   element = document.getElementById(WebString::fromUTF8(kPasswordName));
 317   ASSERT_FALSE(element.isNull());
 318   password_element_ = element.to<WebKit::WebInputElement>();
 319
 320   // Set the expected form origin URL.
 321   std::string origin("data:text/html;charset=utf-8,");
 322   origin += kTextFieldPasswordFormHTML;
 323   fill_data_.basic_data.origin = GURL(origin);
 324
 325   SimulateOnFillPasswordForm(fill_data_);
 326
 327   // Fields should still be empty.
 328   CheckTextFieldsState(std::string(), false, std::string(), false);
 329 }
 330
 331 TEST_F(PasswordAutofillAgentTest, NoAutocompleteForPasswordFieldUsernames) {
 332   const char kPasswordFieldUsernameFormHTML[] =
 333       "<FORM name='LoginTestForm' action='http://www.bidule.com'>"
 334       "  <INPUT type='password' id='username'/>"
 335       "  <INPUT type='password' id='password'/>"
 336       "  <INPUT type='submit' value='Login'/>"
 337       "</FORM>";
 338   LoadHTML(kPasswordFieldUsernameFormHTML);
 339
 340   // Retrieve the input elements so the test can access them.
 341   WebDocument document = GetMainFrame()->document();
 342   WebElement element =
 343       document.getElementById(WebString::fromUTF8(kUsernameName));
 344   ASSERT_FALSE(element.isNull());
 345   username_element_ = element.to<WebKit::WebInputElement>();
 346   element = document.getElementById(WebString::fromUTF8(kPasswordName));
 347   ASSERT_FALSE(element.isNull());
 348   password_element_ = element.to<WebKit::WebInputElement>();
 349
 350   // Set the expected form origin URL.
 351   std::string origin("data:text/html;charset=utf-8,");
 352   origin += kPasswordFieldUsernameFormHTML;
 353   fill_data_.basic_data.origin = GURL(origin);
 354
 355   SimulateOnFillPasswordForm(fill_data_);
 356
 357   // Fields should still be empty.
 358   CheckTextFieldsState(std::string(), false, std::string(), false);
 359 }
 360
 361 // Tests that having a matching username does not preclude the autocomplete.
 362 TEST_F(PasswordAutofillAgentTest, InitialAutocompleteForMatchingFilledField) {
 363   username_element_.setValue(WebString::fromUTF8(kAliceUsername));
 364
 365   // Simulate the browser sending back the login info, it triggers the
 366   // autocomplete.
 367   SimulateOnFillPasswordForm(fill_data_);
 368
 369   // The username and password should have been autocompleted.
 370   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 371 }
 372
 373 // Tests that editing the password clears the autocompleted password field.
 374 TEST_F(PasswordAutofillAgentTest, PasswordClearOnEdit) {
 375   // Simulate the browser sending back the login info, it triggers the
 376   // autocomplete.
 377   SimulateOnFillPasswordForm(fill_data_);
 378
 379   // Simulate the user changing the username to some unknown username.
 380   SimulateUsernameChange("alicia", true);
 381
 382   // The password should have been cleared.
 383   CheckTextFieldsState("alicia", false, std::string(), false);
 384 }
 385
 386 // Tests that we only autocomplete on focus lost and with a full username match
 387 // when |wait_for_username| is true.
 388 TEST_F(PasswordAutofillAgentTest, WaitUsername) {
 389   // Simulate the browser sending back the login info.
 390   fill_data_.wait_for_username = true;
 391   SimulateOnFillPasswordForm(fill_data_);
 392
 393   // No auto-fill should have taken place.
 394   CheckTextFieldsState(std::string(), false, std::string(), false);
 395
 396   // No autocomplete should happen when text is entered in the username.
 397   SimulateUsernameChange("a", true);
 398   CheckTextFieldsState("a", false, std::string(), false);
 399   SimulateUsernameChange("al", true);
 400   CheckTextFieldsState("al", false, std::string(), false);
 401   SimulateUsernameChange(kAliceUsername, true);
 402   CheckTextFieldsState(kAliceUsername, false, std::string(), false);
 403
 404   // Autocomplete should happen only when the username textfield is blurred with
 405   // a full match.
 406   username_element_.setValue("a");
 407   autofill_agent_->textFieldDidEndEditing(username_element_);
 408   CheckTextFieldsState("a", false, std::string(), false);
 409   username_element_.setValue("al");
 410   autofill_agent_->textFieldDidEndEditing(username_element_);
 411   CheckTextFieldsState("al", false, std::string(), false);
 412   username_element_.setValue("alices");
 413   autofill_agent_->textFieldDidEndEditing(username_element_);
 414   CheckTextFieldsState("alices", false, std::string(), false);
 415   username_element_.setValue(ASCIIToUTF16(kAliceUsername));
 416   autofill_agent_->textFieldDidEndEditing(username_element_);
 417   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 418 }
 419
 420 // Tests that inline autocompletion works properly.
 421 TEST_F(PasswordAutofillAgentTest, InlineAutocomplete) {
 422   // Simulate the browser sending back the login info.
 423   SimulateOnFillPasswordForm(fill_data_);
 424
 425   // Clear the text fields to start fresh.
 426   ClearUsernameAndPasswordFields();
 427
 428   // Simulate the user typing in the first letter of 'alice', a stored username.
 429   SimulateUsernameChange("a", true);
 430   // Both the username and password text fields should reflect selection of the
 431   // stored login.
 432   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 433   // And the selection should have been set to 'lice', the last 4 letters.
 434   CheckUsernameSelection(1, 5);
 435
 436   // Now the user types the next letter of the same username, 'l'.
 437   SimulateUsernameChange("al", true);
 438   // Now the fields should have the same value, but the selection should have a
 439   // different start value.
 440   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 441   CheckUsernameSelection(2, 5);
 442
 443   // Test that deleting does not trigger autocomplete.
 444   SimulateKeyDownEvent(username_element_, ui::VKEY_BACK);
 445   SimulateUsernameChange("alic", true);
 446   CheckTextFieldsState("alic", false, std::string(), false);
 447   CheckUsernameSelection(4, 4);  // No selection.
 448   // Reset the last pressed key to something other than backspace.
 449   SimulateKeyDownEvent(username_element_, ui::VKEY_A);
 450
 451   // Now lets say the user goes astray from the stored username and types the
 452   // letter 'f', spelling 'alf'.  We don't know alf (that's just sad), so in
 453   // practice the username should no longer be 'alice' and the selected range
 454   // should be empty.
 455   SimulateUsernameChange("alf", true);
 456   CheckTextFieldsState("alf", false, std::string(), false);
 457   CheckUsernameSelection(3, 3);  // No selection.
 458
 459   // Ok, so now the user removes all the text and enters the letter 'b'.
 460   SimulateUsernameChange("b", true);
 461   // The username and password fields should match the 'bob' entry.
 462   CheckTextFieldsState(kBobUsername, true, kBobPassword, true);
 463   CheckUsernameSelection(1, 3);
 464
 465   // Then, the user again removes all the text and types an uppercase 'C'.
 466   SimulateUsernameChange("C", true);
 467   // The username and password fields should match the 'Carol' entry.
 468   CheckTextFieldsState(kCarolUsername, true, kCarolPassword, true);
 469   CheckUsernameSelection(1, 5);
 470   // The user removes all the text and types a lowercase 'c'.  We only
 471   // want case-sensitive autocompletion, so the username and the selected range
 472   // should be empty.
 473   SimulateUsernameChange("c", true);
 474   CheckTextFieldsState("c", false, std::string(), false);
 475   CheckUsernameSelection(1, 1);
 476
 477   // Check that we complete other_possible_usernames as well.
 478   SimulateUsernameChange("R", true);
 479   CheckTextFieldsState(kCarolAlternateUsername, true, kCarolPassword, true);
 480   CheckUsernameSelection(1, 17);
 481 }
 482
 483 // Tests that selecting an item in the suggestion drop-down no-ops.
 484 TEST_F(PasswordAutofillAgentTest, SuggestionSelect) {
 485   // Simulate the browser sending back the login info.
 486   SimulateOnFillPasswordForm(fill_data_);
 487
 488   // Clear the text fields to start fresh.
 489   ClearUsernameAndPasswordFields();
 490
 491   // To simulate accepting an item in the suggestion drop-down we just mimic
 492   // what the WebView does: it sets the element value then calls
 493   // didSelectAutofillSuggestion on the renderer.
 494   autofill_agent_->didSelectAutofillSuggestion(username_element_,
 495                                                ASCIIToUTF16(kAliceUsername),
 496                                                WebKit::WebString(),
 497                                                0);
 498   // Autocomplete should not have kicked in.
 499   CheckTextFieldsState(std::string(), false, std::string(), false);
 500 }
 501
 502 }  // namespace autofill