src/chrome/browser/autofill/autofill_interactive_uitest.cc

   1 // Copyright (c) 2013 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 <string>
   6
   7 #include "base/basictypes.h"
   8 #include "base/command_line.h"
   9 #include "base/files/file_util.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/rand_util.h"
  13 #include "base/strings/string16.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_split.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "base/time/time.h"
  18 #include "chrome/browser/autofill/personal_data_manager_factory.h"
  19 #include "chrome/browser/chrome_notification_types.h"
  20 #include "chrome/browser/infobars/infobar_service.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/translate/chrome_translate_client.h"
  23 #include "chrome/browser/translate/translate_service.h"
  24 #include "chrome/browser/ui/browser.h"
  25 #include "chrome/browser/ui/browser_window.h"
  26 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  27 #include "chrome/common/render_messages.h"
  28 #include "chrome/test/base/in_process_browser_test.h"
  29 #include "chrome/test/base/interactive_test_utils.h"
  30 #include "chrome/test/base/test_switches.h"
  31 #include "chrome/test/base/ui_test_utils.h"
  32 #include "components/autofill/content/browser/content_autofill_driver.h"
  33 #include "components/autofill/core/browser/autofill_manager.h"
  34 #include "components/autofill/core/browser/autofill_manager_test_delegate.h"
  35 #include "components/autofill/core/browser/autofill_profile.h"
  36 #include "components/autofill/core/browser/autofill_test_utils.h"
  37 #include "components/autofill/core/browser/personal_data_manager.h"
  38 #include "components/autofill/core/browser/personal_data_manager_observer.h"
  39 #include "components/autofill/core/browser/validation.h"
  40 #include "components/infobars/core/confirm_infobar_delegate.h"
  41 #include "components/infobars/core/infobar.h"
  42 #include "components/infobars/core/infobar_manager.h"
  43 #include "components/translate/core/browser/translate_infobar_delegate.h"
  44 #include "content/public/browser/navigation_controller.h"
  45 #include "content/public/browser/notification_observer.h"
  46 #include "content/public/browser/notification_registrar.h"
  47 #include "content/public/browser/notification_service.h"
  48 #include "content/public/browser/render_view_host.h"
  49 #include "content/public/browser/render_widget_host.h"
  50 #include "content/public/browser/web_contents.h"
  51 #include "content/public/test/browser_test_utils.h"
  52 #include "content/public/test/test_renderer_host.h"
  53 #include "content/public/test/test_utils.h"
  54 #include "net/url_request/test_url_fetcher_factory.h"
  55 #include "testing/gmock/include/gmock/gmock.h"
  56 #include "testing/gtest/include/gtest/gtest.h"
  57 #include "ui/events/keycodes/keyboard_codes.h"
  58
  59 using base::ASCIIToUTF16;
  60
  61 namespace autofill {
  62
  63 static const char kDataURIPrefix[] = "data:text/html;charset=utf-8,";
  64 static const char kTestFormString[] =
  65     "<form action=\"http://www.example.com/\" method=\"POST\">"
  66     "<label for=\"firstname\">First name:</label>"
  67     " <input type=\"text\" id=\"firstname\""
  68     "        onfocus=\"domAutomationController.send(true)\"><br>"
  69     "<label for=\"lastname\">Last name:</label>"
  70     " <input type=\"text\" id=\"lastname\"><br>"
  71     "<label for=\"address1\">Address line 1:</label>"
  72     " <input type=\"text\" id=\"address1\"><br>"
  73     "<label for=\"address2\">Address line 2:</label>"
  74     " <input type=\"text\" id=\"address2\"><br>"
  75     "<label for=\"city\">City:</label>"
  76     " <input type=\"text\" id=\"city\"><br>"
  77     "<label for=\"state\">State:</label>"
  78     " <select id=\"state\">"
  79     " <option value=\"\" selected=\"yes\">--</option>"
  80     " <option value=\"CA\">California</option>"
  81     " <option value=\"TX\">Texas</option>"
  82     " </select><br>"
  83     "<label for=\"zip\">ZIP code:</label>"
  84     " <input type=\"text\" id=\"zip\"><br>"
  85     "<label for=\"country\">Country:</label>"
  86     " <select id=\"country\">"
  87     " <option value=\"\" selected=\"yes\">--</option>"
  88     " <option value=\"CA\">Canada</option>"
  89     " <option value=\"US\">United States</option>"
  90     " </select><br>"
  91     "<label for=\"phone\">Phone number:</label>"
  92     " <input type=\"text\" id=\"phone\"><br>"
  93     "</form>";
  94
  95
  96 // AutofillManagerTestDelegateImpl --------------------------------------------
  97
  98 class AutofillManagerTestDelegateImpl
  99     : public autofill::AutofillManagerTestDelegate {
 100  public:
 101   AutofillManagerTestDelegateImpl() {}
 102   virtual ~AutofillManagerTestDelegateImpl() {}
 103
 104   // autofill::AutofillManagerTestDelegate:
 105   virtual void DidPreviewFormData() OVERRIDE {
 106     ASSERT_TRUE(loop_runner_->loop_running());
 107     loop_runner_->Quit();
 108   }
 109
 110   virtual void DidFillFormData() OVERRIDE {
 111     ASSERT_TRUE(loop_runner_->loop_running());
 112     loop_runner_->Quit();
 113   }
 114
 115   virtual void DidShowSuggestions() OVERRIDE {
 116     ASSERT_TRUE(loop_runner_->loop_running());
 117     loop_runner_->Quit();
 118   }
 119
 120   void Reset() {
 121     loop_runner_ = new content::MessageLoopRunner();
 122   }
 123
 124   void Wait() {
 125     loop_runner_->Run();
 126   }
 127
 128  private:
 129   scoped_refptr<content::MessageLoopRunner> loop_runner_;
 130
 131   DISALLOW_COPY_AND_ASSIGN(AutofillManagerTestDelegateImpl);
 132 };
 133
 134
 135 // WindowedPersonalDataManagerObserver ----------------------------------------
 136
 137 class WindowedPersonalDataManagerObserver
 138     : public PersonalDataManagerObserver,
 139       public infobars::InfoBarManager::Observer {
 140  public:
 141   explicit WindowedPersonalDataManagerObserver(Browser* browser)
 142       : alerted_(false),
 143         has_run_message_loop_(false),
 144         browser_(browser),
 145         infobar_service_(InfoBarService::FromWebContents(
 146             browser_->tab_strip_model()->GetActiveWebContents())) {
 147     PersonalDataManagerFactory::GetForProfile(browser_->profile())->
 148         AddObserver(this);
 149     infobar_service_->AddObserver(this);
 150   }
 151
 152   virtual ~WindowedPersonalDataManagerObserver() {
 153     while (infobar_service_->infobar_count() > 0) {
 154       infobar_service_->RemoveInfoBar(infobar_service_->infobar_at(0));
 155     }
 156     infobar_service_->RemoveObserver(this);
 157   }
 158
 159   // PersonalDataManagerObserver:
 160   virtual void OnPersonalDataChanged() OVERRIDE {
 161     if (has_run_message_loop_) {
 162       base::MessageLoopForUI::current()->Quit();
 163       has_run_message_loop_ = false;
 164     }
 165     alerted_ = true;
 166   }
 167
 168   virtual void OnInsufficientFormData() OVERRIDE {
 169     OnPersonalDataChanged();
 170   }
 171
 172
 173   void Wait() {
 174     if (!alerted_) {
 175       has_run_message_loop_ = true;
 176       content::RunMessageLoop();
 177     }
 178     PersonalDataManagerFactory::GetForProfile(browser_->profile())->
 179         RemoveObserver(this);
 180   }
 181
 182  private:
 183   // infobars::InfoBarManager::Observer:
 184   virtual void OnInfoBarAdded(infobars::InfoBar* infobar) OVERRIDE {
 185     infobar_service_->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate()->
 186         Accept();
 187   }
 188
 189   bool alerted_;
 190   bool has_run_message_loop_;
 191   Browser* browser_;
 192   InfoBarService* infobar_service_;
 193
 194   DISALLOW_COPY_AND_ASSIGN(WindowedPersonalDataManagerObserver);
 195 };
 196
 197 // AutofillInteractiveTest ----------------------------------------------------
 198
 199 class AutofillInteractiveTest : public InProcessBrowserTest {
 200  protected:
 201   AutofillInteractiveTest() :
 202       key_press_event_sink_(
 203           base::Bind(&AutofillInteractiveTest::HandleKeyPressEvent,
 204                      base::Unretained(this))) {}
 205   virtual ~AutofillInteractiveTest() {}
 206
 207   // InProcessBrowserTest:
 208   virtual void SetUpOnMainThread() OVERRIDE {
 209     // Don't want Keychain coming up on Mac.
 210     test::DisableSystemServices(browser()->profile()->GetPrefs());
 211
 212     // Inject the test delegate into the AutofillManager.
 213     content::WebContents* web_contents = GetWebContents();
 214     ContentAutofillDriver* autofill_driver =
 215         ContentAutofillDriver::FromWebContents(web_contents);
 216     AutofillManager* autofill_manager = autofill_driver->autofill_manager();
 217     autofill_manager->SetTestDelegate(&test_delegate_);
 218
 219     // If the mouse happened to be over where the suggestions are shown, then
 220     // the preview will show up and will fail the tests. We need to give it a
 221     // point that's within the browser frame, or else the method hangs.
 222     gfx::Point reset_mouse(GetWebContents()->GetContainerBounds().origin());
 223     reset_mouse = gfx::Point(reset_mouse.x() + 5, reset_mouse.y() + 5);
 224     ASSERT_TRUE(ui_test_utils::SendMouseMoveSync(reset_mouse));
 225   }
 226
 227   virtual void TearDownOnMainThread() OVERRIDE {
 228     // Make sure to close any showing popups prior to tearing down the UI.
 229     content::WebContents* web_contents = GetWebContents();
 230     AutofillManager* autofill_manager = ContentAutofillDriver::FromWebContents(
 231                                             web_contents)->autofill_manager();
 232     autofill_manager->client()->HideAutofillPopup();
 233   }
 234
 235   PersonalDataManager* GetPersonalDataManager() {
 236     return PersonalDataManagerFactory::GetForProfile(browser()->profile());
 237   }
 238
 239   content::WebContents* GetWebContents() {
 240     return browser()->tab_strip_model()->GetActiveWebContents();
 241   }
 242
 243   content::RenderViewHost* GetRenderViewHost() {
 244     return GetWebContents()->GetRenderViewHost();
 245   }
 246
 247   void CreateTestProfile() {
 248     AutofillProfile profile;
 249     test::SetProfileInfo(
 250         &profile, "Milton", "C.", "Waddams",
 251         "red.swingline@initech.com", "Initech", "4120 Freidrich Lane",
 252         "Basement", "Austin", "Texas", "78744", "US", "5125551234");
 253
 254     WindowedPersonalDataManagerObserver observer(browser());
 255     GetPersonalDataManager()->AddProfile(profile);
 256
 257     // AddProfile is asynchronous. Wait for it to finish before continuing the
 258     // tests.
 259     observer.Wait();
 260   }
 261
 262   void SetProfiles(std::vector<AutofillProfile>* profiles) {
 263     WindowedPersonalDataManagerObserver observer(browser());
 264     GetPersonalDataManager()->SetProfiles(profiles);
 265     observer.Wait();
 266   }
 267
 268   void SetProfile(const AutofillProfile& profile) {
 269     std::vector<AutofillProfile> profiles;
 270     profiles.push_back(profile);
 271     SetProfiles(&profiles);
 272   }
 273
 274   // Populates a webpage form using autofill data and keypress events.
 275   // This function focuses the specified input field in the form, and then
 276   // sends keypress events to the tab to cause the form to be populated.
 277   void PopulateForm(const std::string& field_id) {
 278     std::string js("document.getElementById('" + field_id + "').focus();");
 279     ASSERT_TRUE(content::ExecuteScript(GetRenderViewHost(), js));
 280
 281     SendKeyToPageAndWait(ui::VKEY_DOWN);
 282     SendKeyToPopupAndWait(ui::VKEY_DOWN);
 283     SendKeyToPopupAndWait(ui::VKEY_RETURN);
 284   }
 285
 286   void ExpectFieldValue(const std::string& field_name,
 287                         const std::string& expected_value) {
 288     std::string value;
 289     ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 290         GetWebContents(),
 291         "window.domAutomationController.send("
 292         "    document.getElementById('" + field_name + "').value);",
 293         &value));
 294     EXPECT_EQ(expected_value, value);
 295   }
 296
 297   void GetFieldBackgroundColor(const std::string& field_name,
 298                                std::string* color) {
 299     ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 300         GetWebContents(),
 301         "window.domAutomationController.send("
 302         "    document.defaultView.getComputedStyle(document.getElementById('" +
 303         field_name + "')).backgroundColor);",
 304         color));
 305   }
 306
 307   void SimulateURLFetch(bool success) {
 308     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
 309     ASSERT_TRUE(fetcher);
 310     net::URLRequestStatus status;
 311     status.set_status(success ? net::URLRequestStatus::SUCCESS :
 312                                 net::URLRequestStatus::FAILED);
 313
 314     std::string script = " var google = {};"
 315         "google.translate = (function() {"
 316         "  return {"
 317         "    TranslateService: function() {"
 318         "      return {"
 319         "        isAvailable : function() {"
 320         "          return true;"
 321         "        },"
 322         "        restore : function() {"
 323         "          return;"
 324         "        },"
 325         "        getDetectedLanguage : function() {"
 326         "          return \"ja\";"
 327         "        },"
 328         "        translatePage : function(originalLang, targetLang,"
 329         "                                 onTranslateProgress) {"
 330         "          document.getElementsByTagName(\"body\")[0].innerHTML = '" +
 331         std::string(kTestFormString) +
 332         "              ';"
 333         "          onTranslateProgress(100, true, false);"
 334         "        }"
 335         "      };"
 336         "    }"
 337         "  };"
 338         "})();"
 339         "cr.googleTranslate.onTranslateElementLoad();";
 340
 341     fetcher->set_url(fetcher->GetOriginalURL());
 342     fetcher->set_status(status);
 343     fetcher->set_response_code(success ? 200 : 500);
 344     fetcher->SetResponseString(script);
 345     fetcher->delegate()->OnURLFetchComplete(fetcher);
 346   }
 347
 348   void FocusFirstNameField() {
 349     bool result = false;
 350     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 351         GetRenderViewHost(),
 352         "if (document.readyState === 'complete')"
 353         "  document.getElementById('firstname').focus();"
 354         "else"
 355         "  domAutomationController.send(false);",
 356         &result));
 357     ASSERT_TRUE(result);
 358   }
 359
 360   // Simulates a click on the middle of the DOM element with the given |id|.
 361   void ClickElementWithId(const std::string& id) {
 362     int x;
 363     ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
 364         GetRenderViewHost(),
 365         "var bounds = document.getElementById('" +
 366             id +
 367             "').getBoundingClientRect();"
 368             "domAutomationController.send("
 369             "    Math.floor(bounds.left + bounds.width / 2));",
 370         &x));
 371     int y;
 372     ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
 373         GetRenderViewHost(),
 374         "var bounds = document.getElementById('" +
 375             id +
 376             "').getBoundingClientRect();"
 377             "domAutomationController.send("
 378             "    Math.floor(bounds.top + bounds.height / 2));",
 379         &y));
 380     content::SimulateMouseClickAt(GetWebContents(),
 381                                   0,
 382                                   blink::WebMouseEvent::ButtonLeft,
 383                                   gfx::Point(x, y));
 384   }
 385
 386   void ClickFirstNameField() {
 387     ASSERT_NO_FATAL_FAILURE(ClickElementWithId("firstname"));
 388   }
 389
 390   // Make a pointless round trip to the renderer, giving the popup a chance to
 391   // show if it's going to. If it does show, an assert in
 392   // AutofillManagerTestDelegateImpl will trigger.
 393   void MakeSurePopupDoesntAppear() {
 394     int unused;
 395     ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
 396         GetRenderViewHost(), "domAutomationController.send(42)", &unused));
 397   }
 398
 399   void ExpectFilledTestForm() {
 400     ExpectFieldValue("firstname", "Milton");
 401     ExpectFieldValue("lastname", "Waddams");
 402     ExpectFieldValue("address1", "4120 Freidrich Lane");
 403     ExpectFieldValue("address2", "Basement");
 404     ExpectFieldValue("city", "Austin");
 405     ExpectFieldValue("state", "TX");
 406     ExpectFieldValue("zip", "78744");
 407     ExpectFieldValue("country", "US");
 408     ExpectFieldValue("phone", "5125551234");
 409   }
 410
 411   void SendKeyToPageAndWait(ui::KeyboardCode key) {
 412     test_delegate_.Reset();
 413     content::SimulateKeyPress(
 414         GetWebContents(), key, false, false, false, false);
 415     test_delegate_.Wait();
 416   }
 417
 418   bool HandleKeyPressEvent(const content::NativeWebKeyboardEvent& event) {
 419     return true;
 420   }
 421
 422   void SendKeyToPopupAndWait(ui::KeyboardCode key) {
 423     // Route popup-targeted key presses via the render view host.
 424     content::NativeWebKeyboardEvent event;
 425     event.windowsKeyCode = key;
 426     event.type = blink::WebKeyboardEvent::RawKeyDown;
 427     test_delegate_.Reset();
 428     // Install the key press event sink to ensure that any events that are not
 429     // handled by the installed callbacks do not end up crashing the test.
 430     GetRenderViewHost()->AddKeyPressEventCallback(key_press_event_sink_);
 431     GetRenderViewHost()->ForwardKeyboardEvent(event);
 432     test_delegate_.Wait();
 433     GetRenderViewHost()->RemoveKeyPressEventCallback(key_press_event_sink_);
 434   }
 435
 436   // Datalist does not support autofill preview. There is no need to start
 437   // message loop for Datalist.
 438   void SendKeyToDataListPopup(ui::KeyboardCode key) {
 439     // Route popup-targeted key presses via the render view host.
 440     content::NativeWebKeyboardEvent event;
 441     event.windowsKeyCode = key;
 442     event.type = blink::WebKeyboardEvent::RawKeyDown;
 443     // Install the key press event sink to ensure that any events that are not
 444     // handled by the installed callbacks do not end up crashing the test.
 445     GetRenderViewHost()->AddKeyPressEventCallback(key_press_event_sink_);
 446     GetRenderViewHost()->ForwardKeyboardEvent(event);
 447     GetRenderViewHost()->RemoveKeyPressEventCallback(key_press_event_sink_);
 448   }
 449
 450   void TryBasicFormFill() {
 451     FocusFirstNameField();
 452
 453     // Start filling the first name field with "M" and wait for the popup to be
 454     // shown.
 455     SendKeyToPageAndWait(ui::VKEY_M);
 456
 457     // Press the down arrow to select the suggestion and preview the autofilled
 458     // form.
 459     SendKeyToPopupAndWait(ui::VKEY_DOWN);
 460
 461     // The previewed values should not be accessible to JavaScript.
 462     ExpectFieldValue("firstname", "M");
 463     ExpectFieldValue("lastname", std::string());
 464     ExpectFieldValue("address1", std::string());
 465     ExpectFieldValue("address2", std::string());
 466     ExpectFieldValue("city", std::string());
 467     ExpectFieldValue("state", std::string());
 468     ExpectFieldValue("zip", std::string());
 469     ExpectFieldValue("country", std::string());
 470     ExpectFieldValue("phone", std::string());
 471     // TODO(isherman): It would be nice to test that the previewed values are
 472     // displayed: http://crbug.com/57220
 473
 474     // Press Enter to accept the autofill suggestions.
 475     SendKeyToPopupAndWait(ui::VKEY_RETURN);
 476
 477     // The form should be filled.
 478     ExpectFilledTestForm();
 479   }
 480
 481   AutofillManagerTestDelegateImpl* test_delegate() { return &test_delegate_; }
 482
 483  private:
 484   AutofillManagerTestDelegateImpl test_delegate_;
 485
 486   net::TestURLFetcherFactory url_fetcher_factory_;
 487
 488   // KeyPressEventCallback that serves as a sink to ensure that every key press
 489   // event the tests create and have the WebContents forward is handled by some
 490   // key press event callback. It is necessary to have this sinkbecause if no
 491   // key press event callback handles the event (at least on Mac), a DCHECK
 492   // ends up going off that the |event| doesn't have an |os_event| associated
 493   // with it.
 494   content::RenderWidgetHost::KeyPressEventCallback key_press_event_sink_;
 495
 496   DISALLOW_COPY_AND_ASSIGN(AutofillInteractiveTest);
 497 };
 498
 499 // Test that basic form fill is working.
 500 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, BasicFormFill) {
 501   CreateTestProfile();
 502
 503   // Load the test page.
 504   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 505       GURL(std::string(kDataURIPrefix) + kTestFormString)));
 506
 507   // Invoke Autofill.
 508   TryBasicFormFill();
 509 }
 510
 511 // Test that form filling can be initiated by pressing the down arrow.
 512 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, AutofillViaDownArrow) {
 513   CreateTestProfile();
 514
 515   // Load the test page.
 516   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 517       GURL(std::string(kDataURIPrefix) + kTestFormString)));
 518
 519   // Focus a fillable field.
 520   FocusFirstNameField();
 521
 522   // Press the down arrow to initiate Autofill and wait for the popup to be
 523   // shown.
 524   SendKeyToPageAndWait(ui::VKEY_DOWN);
 525
 526   // Press the down arrow to select the suggestion and preview the autofilled
 527   // form.
 528   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 529
 530   // Press Enter to accept the autofill suggestions.
 531   SendKeyToPopupAndWait(ui::VKEY_RETURN);
 532
 533   // The form should be filled.
 534   ExpectFilledTestForm();
 535 }
 536
 537 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, AutofillSelectViaTab) {
 538   CreateTestProfile();
 539
 540   // Load the test page.
 541   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 542       GURL(std::string(kDataURIPrefix) + kTestFormString)));
 543
 544   // Focus a fillable field.
 545   FocusFirstNameField();
 546
 547   // Press the down arrow to initiate Autofill and wait for the popup to be
 548   // shown.
 549   SendKeyToPageAndWait(ui::VKEY_DOWN);
 550
 551   // Press the down arrow to select the suggestion and preview the autofilled
 552   // form.
 553   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 554
 555   // Press tab to accept the autofill suggestions.
 556   SendKeyToPopupAndWait(ui::VKEY_TAB);
 557
 558   // The form should be filled.
 559   ExpectFilledTestForm();
 560 }
 561
 562 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, AutofillViaClick) {
 563   CreateTestProfile();
 564
 565   // Load the test page.
 566   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 567       browser(), GURL(std::string(kDataURIPrefix) + kTestFormString)));
 568   // Focus a fillable field.
 569   ASSERT_NO_FATAL_FAILURE(FocusFirstNameField());
 570
 571   // Now click it.
 572   test_delegate()->Reset();
 573   ASSERT_NO_FATAL_FAILURE(ClickFirstNameField());
 574   test_delegate()->Wait();
 575
 576   // Press the down arrow to select the suggestion and preview the autofilled
 577   // form.
 578   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 579
 580   // Press Enter to accept the autofill suggestions.
 581   SendKeyToPopupAndWait(ui::VKEY_RETURN);
 582
 583   // The form should be filled.
 584   ExpectFilledTestForm();
 585 }
 586
 587 // Makes sure that the first click does *not* activate the popup.
 588 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, DontAutofillForFirstClick) {
 589   CreateTestProfile();
 590
 591   // Load the test page.
 592   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 593       browser(), GURL(std::string(kDataURIPrefix) + kTestFormString)));
 594
 595   // Click the first name field while it's out of focus, then twiddle our thumbs
 596   // a bit. If a popup were to show, it would hit the asserts in
 597   // AutofillManagerTestDelegateImpl while we're wasting time.
 598   ASSERT_NO_FATAL_FAILURE(ClickFirstNameField());
 599   ASSERT_NO_FATAL_FAILURE(MakeSurePopupDoesntAppear());
 600
 601   // The second click should activate the popup since the first click focused
 602   // the field.
 603   test_delegate()->Reset();
 604   ASSERT_NO_FATAL_FAILURE(ClickFirstNameField());
 605   test_delegate()->Wait();
 606 }
 607
 608 // Makes sure that clicking outside the focused field doesn't activate
 609 // the popup.
 610 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, DontAutofillForOutsideClick) {
 611   CreateTestProfile();
 612
 613   // Load the test page.
 614   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 615       browser(),
 616       GURL(std::string(kDataURIPrefix) + kTestFormString +
 617            "<button disabled id='disabled-button'>Cant click this</button>")));
 618
 619   ASSERT_NO_FATAL_FAILURE(FocusFirstNameField());
 620
 621   // Clicking a disabled button will generate a mouse event but focus doesn't
 622   // change. This tests that autofill can handle a mouse event outside a focused
 623   // input *without* showing the popup.
 624   ASSERT_NO_FATAL_FAILURE(ClickElementWithId("disabled-button"));
 625   ASSERT_NO_FATAL_FAILURE(MakeSurePopupDoesntAppear());
 626
 627   test_delegate()->Reset();
 628   ASSERT_NO_FATAL_FAILURE(ClickFirstNameField());
 629   test_delegate()->Wait();
 630 }
 631
 632 // Test that a field is still autofillable after the previously autofilled
 633 // value is deleted.
 634 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, OnDeleteValueAfterAutofill) {
 635   CreateTestProfile();
 636
 637   // Load the test page.
 638   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 639       GURL(std::string(kDataURIPrefix) + kTestFormString)));
 640
 641   // Invoke and accept the Autofill popup and verify the form was filled.
 642   FocusFirstNameField();
 643   SendKeyToPageAndWait(ui::VKEY_M);
 644   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 645   SendKeyToPopupAndWait(ui::VKEY_RETURN);
 646   ExpectFilledTestForm();
 647
 648   // Delete the value of a filled field.
 649   ASSERT_TRUE(content::ExecuteScript(
 650       GetRenderViewHost(),
 651       "document.getElementById('firstname').value = '';"));
 652   ExpectFieldValue("firstname", "");
 653
 654   // Invoke and accept the Autofill popup and verify the field was filled.
 655   SendKeyToPageAndWait(ui::VKEY_M);
 656   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 657   SendKeyToPopupAndWait(ui::VKEY_RETURN);
 658   ExpectFieldValue("firstname", "Milton");
 659 }
 660
 661 // Test that an input field is not rendered with the yellow autofilled
 662 // background color when choosing an option from the datalist suggestion list.
 663 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, OnSelectOptionFromDatalist) {
 664   // Load the test page.
 665   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 666       browser(),
 667       GURL(std::string(kDataURIPrefix) +
 668            "<form action=\"http://www.example.com/\" method=\"POST\">"
 669            "  <input list=\"dl\" type=\"search\" id=\"firstname\""
 670            "         onfocus=\"domAutomationController.send(true)\"><br>"
 671            "  <datalist id=\"dl\">"
 672            "  <option value=\"Adam\"></option>"
 673            "  <option value=\"Bob\"></option>"
 674            "  <option value=\"Carl\"></option>"
 675            "  </datalist>"
 676            "</form>")));
 677   std::string orginalcolor;
 678   GetFieldBackgroundColor("firstname", &orginalcolor);
 679
 680   FocusFirstNameField();
 681   SendKeyToPageAndWait(ui::VKEY_DOWN);
 682   SendKeyToDataListPopup(ui::VKEY_DOWN);
 683   SendKeyToDataListPopup(ui::VKEY_RETURN);
 684   ExpectFieldValue("firstname", "Adam");
 685   std::string color;
 686   GetFieldBackgroundColor("firstname", &color);
 687   EXPECT_EQ(color, orginalcolor);
 688 }
 689
 690 // Test that a JavaScript oninput event is fired after auto-filling a form.
 691 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, OnInputAfterAutofill) {
 692   CreateTestProfile();
 693
 694   const char kOnInputScript[] =
 695       "<script>"
 696       "focused_fired = false;"
 697       "unfocused_fired = false;"
 698       "changed_select_fired = false;"
 699       "unchanged_select_fired = false;"
 700       "document.getElementById('firstname').oninput = function() {"
 701       "  focused_fired = true;"
 702       "};"
 703       "document.getElementById('lastname').oninput = function() {"
 704       "  unfocused_fired = true;"
 705       "};"
 706       "document.getElementById('state').oninput = function() {"
 707       "  changed_select_fired = true;"
 708       "};"
 709       "document.getElementById('country').oninput = function() {"
 710       "  unchanged_select_fired = true;"
 711       "};"
 712       "document.getElementById('country').value = 'US';"
 713       "</script>";
 714
 715   // Load the test page.
 716   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 717       GURL(std::string(kDataURIPrefix) + kTestFormString + kOnInputScript)));
 718
 719   // Invoke Autofill.
 720   FocusFirstNameField();
 721
 722   // Start filling the first name field with "M" and wait for the popup to be
 723   // shown.
 724   SendKeyToPageAndWait(ui::VKEY_M);
 725
 726   // Press the down arrow to select the suggestion and preview the autofilled
 727   // form.
 728   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 729
 730   // Press Enter to accept the autofill suggestions.
 731   SendKeyToPopupAndWait(ui::VKEY_RETURN);
 732
 733   // The form should be filled.
 734   ExpectFilledTestForm();
 735
 736   bool focused_fired = false;
 737   bool unfocused_fired = false;
 738   bool changed_select_fired = false;
 739   bool unchanged_select_fired = false;
 740   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 741       GetRenderViewHost(),
 742       "domAutomationController.send(focused_fired);",
 743       &focused_fired));
 744   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 745       GetRenderViewHost(),
 746       "domAutomationController.send(unfocused_fired);",
 747       &unfocused_fired));
 748   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 749       GetRenderViewHost(),
 750       "domAutomationController.send(changed_select_fired);",
 751       &changed_select_fired));
 752   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 753       GetRenderViewHost(),
 754       "domAutomationController.send(unchanged_select_fired);",
 755       &unchanged_select_fired));
 756   EXPECT_TRUE(focused_fired);
 757   EXPECT_TRUE(unfocused_fired);
 758   EXPECT_TRUE(changed_select_fired);
 759   EXPECT_FALSE(unchanged_select_fired);
 760 }
 761
 762 // Test that a JavaScript onchange event is fired after auto-filling a form.
 763 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, OnChangeAfterAutofill) {
 764   CreateTestProfile();
 765
 766   const char kOnChangeScript[] =
 767       "<script>"
 768       "focused_fired = false;"
 769       "unfocused_fired = false;"
 770       "changed_select_fired = false;"
 771       "unchanged_select_fired = false;"
 772       "document.getElementById('firstname').onchange = function() {"
 773       "  focused_fired = true;"
 774       "};"
 775       "document.getElementById('lastname').onchange = function() {"
 776       "  unfocused_fired = true;"
 777       "};"
 778       "document.getElementById('state').onchange = function() {"
 779       "  changed_select_fired = true;"
 780       "};"
 781       "document.getElementById('country').onchange = function() {"
 782       "  unchanged_select_fired = true;"
 783       "};"
 784       "document.getElementById('country').value = 'US';"
 785       "</script>";
 786
 787   // Load the test page.
 788   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 789       GURL(std::string(kDataURIPrefix) + kTestFormString + kOnChangeScript)));
 790
 791   // Invoke Autofill.
 792   FocusFirstNameField();
 793
 794   // Start filling the first name field with "M" and wait for the popup to be
 795   // shown.
 796   SendKeyToPageAndWait(ui::VKEY_M);
 797
 798   // Press the down arrow to select the suggestion and preview the autofilled
 799   // form.
 800   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 801
 802   // Press Enter to accept the autofill suggestions.
 803   SendKeyToPopupAndWait(ui::VKEY_RETURN);
 804
 805   // The form should be filled.
 806   ExpectFilledTestForm();
 807
 808   bool focused_fired = false;
 809   bool unfocused_fired = false;
 810   bool changed_select_fired = false;
 811   bool unchanged_select_fired = false;
 812   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 813       GetRenderViewHost(),
 814       "domAutomationController.send(focused_fired);",
 815       &focused_fired));
 816   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 817       GetRenderViewHost(),
 818       "domAutomationController.send(unfocused_fired);",
 819       &unfocused_fired));
 820   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 821       GetRenderViewHost(),
 822       "domAutomationController.send(changed_select_fired);",
 823       &changed_select_fired));
 824   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 825       GetRenderViewHost(),
 826       "domAutomationController.send(unchanged_select_fired);",
 827       &unchanged_select_fired));
 828   EXPECT_TRUE(focused_fired);
 829   EXPECT_TRUE(unfocused_fired);
 830   EXPECT_TRUE(changed_select_fired);
 831   EXPECT_FALSE(unchanged_select_fired);
 832 }
 833
 834 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, InputFiresBeforeChange) {
 835   CreateTestProfile();
 836
 837   const char kInputFiresBeforeChangeScript[] =
 838       "<script>"
 839       "inputElementEvents = [];"
 840       "function recordInputElementEvent(e) {"
 841       "  if (e.target.tagName != 'INPUT') throw 'only <input> tags allowed';"
 842       "  inputElementEvents.push(e.type);"
 843       "}"
 844       "selectElementEvents = [];"
 845       "function recordSelectElementEvent(e) {"
 846       "  if (e.target.tagName != 'SELECT') throw 'only <select> tags allowed';"
 847       "  selectElementEvents.push(e.type);"
 848       "}"
 849       "document.getElementById('lastname').oninput = recordInputElementEvent;"
 850       "document.getElementById('lastname').onchange = recordInputElementEvent;"
 851       "document.getElementById('country').oninput = recordSelectElementEvent;"
 852       "document.getElementById('country').onchange = recordSelectElementEvent;"
 853       "</script>";
 854
 855   // Load the test page.
 856   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 857       GURL(std::string(kDataURIPrefix) + kTestFormString +
 858            kInputFiresBeforeChangeScript)));
 859
 860   // Invoke and accept the Autofill popup and verify the form was filled.
 861   FocusFirstNameField();
 862   SendKeyToPageAndWait(ui::VKEY_M);
 863   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 864   SendKeyToPopupAndWait(ui::VKEY_RETURN);
 865   ExpectFilledTestForm();
 866
 867   int num_input_element_events = -1;
 868   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
 869       GetRenderViewHost(),
 870       "domAutomationController.send(inputElementEvents.length);",
 871       &num_input_element_events));
 872   EXPECT_EQ(2, num_input_element_events);
 873
 874   std::vector<std::string> input_element_events;
 875   input_element_events.resize(2);
 876
 877   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 878       GetRenderViewHost(),
 879       "domAutomationController.send(inputElementEvents[0]);",
 880       &input_element_events[0]));
 881   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 882       GetRenderViewHost(),
 883       "domAutomationController.send(inputElementEvents[1]);",
 884       &input_element_events[1]));
 885
 886   EXPECT_EQ("input", input_element_events[0]);
 887   EXPECT_EQ("change", input_element_events[1]);
 888
 889   int num_select_element_events = -1;
 890   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
 891       GetRenderViewHost(),
 892       "domAutomationController.send(selectElementEvents.length);",
 893       &num_select_element_events));
 894   EXPECT_EQ(2, num_select_element_events);
 895
 896   std::vector<std::string> select_element_events;
 897   select_element_events.resize(2);
 898
 899   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 900       GetRenderViewHost(),
 901       "domAutomationController.send(selectElementEvents[0]);",
 902       &select_element_events[0]));
 903   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 904       GetRenderViewHost(),
 905       "domAutomationController.send(selectElementEvents[1]);",
 906       &select_element_events[1]));
 907
 908   EXPECT_EQ("input", select_element_events[0]);
 909   EXPECT_EQ("change", select_element_events[1]);
 910 }
 911
 912 // Test that we can autofill forms distinguished only by their |id| attribute.
 913 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest,
 914                        AutofillFormsDistinguishedById) {
 915   CreateTestProfile();
 916
 917   // Load the test page.
 918   const std::string kURL =
 919       std::string(kDataURIPrefix) + kTestFormString +
 920       "<script>"
 921       "var mainForm = document.forms[0];"
 922       "mainForm.id = 'mainForm';"
 923       "var newForm = document.createElement('form');"
 924       "newForm.action = mainForm.action;"
 925       "newForm.method = mainForm.method;"
 926       "newForm.id = 'newForm';"
 927       "mainForm.parentNode.insertBefore(newForm, mainForm);"
 928       "</script>";
 929   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(), GURL(kURL)));
 930
 931   // Invoke Autofill.
 932   TryBasicFormFill();
 933 }
 934
 935 // Test that we properly autofill forms with repeated fields.
 936 // In the wild, the repeated fields are typically either email fields
 937 // (duplicated for "confirmation"); or variants that are hot-swapped via
 938 // JavaScript, with only one actually visible at any given time.
 939 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, AutofillFormWithRepeatedField) {
 940   CreateTestProfile();
 941
 942   // Load the test page.
 943   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 944       GURL(std::string(kDataURIPrefix) +
 945            "<form action=\"http://www.example.com/\" method=\"POST\">"
 946            "<label for=\"firstname\">First name:</label>"
 947            " <input type=\"text\" id=\"firstname\""
 948            "        onfocus=\"domAutomationController.send(true)\"><br>"
 949            "<label for=\"lastname\">Last name:</label>"
 950            " <input type=\"text\" id=\"lastname\"><br>"
 951            "<label for=\"address1\">Address line 1:</label>"
 952            " <input type=\"text\" id=\"address1\"><br>"
 953            "<label for=\"address2\">Address line 2:</label>"
 954            " <input type=\"text\" id=\"address2\"><br>"
 955            "<label for=\"city\">City:</label>"
 956            " <input type=\"text\" id=\"city\"><br>"
 957            "<label for=\"state\">State:</label>"
 958            " <select id=\"state\">"
 959            " <option value=\"\" selected=\"yes\">--</option>"
 960            " <option value=\"CA\">California</option>"
 961            " <option value=\"TX\">Texas</option>"
 962            " </select><br>"
 963            "<label for=\"state_freeform\" style=\"display:none\">State:</label>"
 964            " <input type=\"text\" id=\"state_freeform\""
 965            "        style=\"display:none\"><br>"
 966            "<label for=\"zip\">ZIP code:</label>"
 967            " <input type=\"text\" id=\"zip\"><br>"
 968            "<label for=\"country\">Country:</label>"
 969            " <select id=\"country\">"
 970            " <option value=\"\" selected=\"yes\">--</option>"
 971            " <option value=\"CA\">Canada</option>"
 972            " <option value=\"US\">United States</option>"
 973            " </select><br>"
 974            "<label for=\"phone\">Phone number:</label>"
 975            " <input type=\"text\" id=\"phone\"><br>"
 976            "</form>")));
 977
 978   // Invoke Autofill.
 979   TryBasicFormFill();
 980   ExpectFieldValue("state_freeform", std::string());
 981 }
 982
 983 // Test that we properly autofill forms with non-autofillable fields.
 984 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest,
 985                        AutofillFormWithNonAutofillableField) {
 986   CreateTestProfile();
 987
 988   // Load the test page.
 989   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
 990       GURL(std::string(kDataURIPrefix) +
 991            "<form action=\"http://www.example.com/\" method=\"POST\">"
 992            "<label for=\"firstname\">First name:</label>"
 993            " <input type=\"text\" id=\"firstname\""
 994            "        onfocus=\"domAutomationController.send(true)\"><br>"
 995            "<label for=\"middlename\">Middle name:</label>"
 996            " <input type=\"text\" id=\"middlename\" autocomplete=\"off\" /><br>"
 997            "<label for=\"lastname\">Last name:</label>"
 998            " <input type=\"text\" id=\"lastname\"><br>"
 999            "<label for=\"address1\">Address line 1:</label>"
1000            " <input type=\"text\" id=\"address1\"><br>"
1001            "<label for=\"address2\">Address line 2:</label>"
1002            " <input type=\"text\" id=\"address2\"><br>"
1003            "<label for=\"city\">City:</label>"
1004            " <input type=\"text\" id=\"city\"><br>"
1005            "<label for=\"state\">State:</label>"
1006            " <select id=\"state\">"
1007            " <option value=\"\" selected=\"yes\">--</option>"
1008            " <option value=\"CA\">California</option>"
1009            " <option value=\"TX\">Texas</option>"
1010            " </select><br>"
1011            "<label for=\"zip\">ZIP code:</label>"
1012            " <input type=\"text\" id=\"zip\"><br>"
1013            "<label for=\"country\">Country:</label>"
1014            " <select id=\"country\">"
1015            " <option value=\"\" selected=\"yes\">--</option>"
1016            " <option value=\"CA\">Canada</option>"
1017            " <option value=\"US\">United States</option>"
1018            " </select><br>"
1019            "<label for=\"phone\">Phone number:</label>"
1020            " <input type=\"text\" id=\"phone\"><br>"
1021            "</form>")));
1022
1023   // Invoke Autofill.
1024   TryBasicFormFill();
1025 }
1026
1027 // Test that we can Autofill dynamically generated forms.
1028 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, DynamicFormFill) {
1029   CreateTestProfile();
1030
1031   // Load the test page.
1032   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
1033       GURL(std::string(kDataURIPrefix) +
1034            "<form id=\"form\" action=\"http://www.example.com/\""
1035            "      method=\"POST\"></form>"
1036            "<script>"
1037            "function AddElement(name, label) {"
1038            "  var form = document.getElementById('form');"
1039            ""
1040            "  var label_text = document.createTextNode(label);"
1041            "  var label_element = document.createElement('label');"
1042            "  label_element.setAttribute('for', name);"
1043            "  label_element.appendChild(label_text);"
1044            "  form.appendChild(label_element);"
1045            ""
1046            "  if (name === 'state' || name === 'country') {"
1047            "    var select_element = document.createElement('select');"
1048            "    select_element.setAttribute('id', name);"
1049            "    select_element.setAttribute('name', name);"
1050            ""
1051            "    /* Add an empty selected option. */"
1052            "    var default_option = new Option('--', '', true);"
1053            "    select_element.appendChild(default_option);"
1054            ""
1055            "    /* Add the other options. */"
1056            "    if (name == 'state') {"
1057            "      var option1 = new Option('California', 'CA');"
1058            "      select_element.appendChild(option1);"
1059            "      var option2 = new Option('Texas', 'TX');"
1060            "      select_element.appendChild(option2);"
1061            "    } else {"
1062            "      var option1 = new Option('Canada', 'CA');"
1063            "      select_element.appendChild(option1);"
1064            "      var option2 = new Option('United States', 'US');"
1065            "      select_element.appendChild(option2);"
1066            "    }"
1067            ""
1068            "    form.appendChild(select_element);"
1069            "  } else {"
1070            "    var input_element = document.createElement('input');"
1071            "    input_element.setAttribute('id', name);"
1072            "    input_element.setAttribute('name', name);"
1073            ""
1074            "    /* Add the onfocus listener to the 'firstname' field. */"
1075            "    if (name === 'firstname') {"
1076            "      input_element.onfocus = function() {"
1077            "        domAutomationController.send(true);"
1078            "      };"
1079            "    }"
1080            ""
1081            "    form.appendChild(input_element);"
1082            "  }"
1083            ""
1084            "  form.appendChild(document.createElement('br'));"
1085            "};"
1086            ""
1087            "function BuildForm() {"
1088            "  var elements = ["
1089            "    ['firstname', 'First name:'],"
1090            "    ['lastname', 'Last name:'],"
1091            "    ['address1', 'Address line 1:'],"
1092            "    ['address2', 'Address line 2:'],"
1093            "    ['city', 'City:'],"
1094            "    ['state', 'State:'],"
1095            "    ['zip', 'ZIP code:'],"
1096            "    ['country', 'Country:'],"
1097            "    ['phone', 'Phone number:'],"
1098            "  ];"
1099            ""
1100            "  for (var i = 0; i < elements.length; i++) {"
1101            "    var name = elements[i][0];"
1102            "    var label = elements[i][1];"
1103            "    AddElement(name, label);"
1104            "  }"
1105            "};"
1106            "</script>")));
1107
1108   // Dynamically construct the form.
1109   ASSERT_TRUE(content::ExecuteScript(GetRenderViewHost(), "BuildForm();"));
1110
1111   // Invoke Autofill.
1112   TryBasicFormFill();
1113 }
1114
1115 // Test that form filling works after reloading the current page.
1116 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, AutofillAfterReload) {
1117   CreateTestProfile();
1118
1119   // Load the test page.
1120   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
1121       GURL(std::string(kDataURIPrefix) + kTestFormString)));
1122
1123   // Reload the page.
1124   content::WebContents* web_contents = GetWebContents();
1125   web_contents->GetController().Reload(false);
1126   content::WaitForLoadStop(web_contents);
1127
1128   // Invoke Autofill.
1129   TryBasicFormFill();
1130 }
1131
1132 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, AutofillAfterTranslate) {
1133   // TODO(port): Test corresponding bubble translate UX: http://crbug.com/383235
1134   if (TranslateService::IsTranslateBubbleEnabled())
1135     return;
1136
1137   CreateTestProfile();
1138
1139   GURL url(std::string(kDataURIPrefix) +
1140                "<form action=\"http://www.example.com/\" method=\"POST\">"
1141                "<label for=\"fn\">なまえ</label>"
1142                " <input type=\"text\" id=\"fn\""
1143                "        onfocus=\"domAutomationController.send(true)\""
1144                "><br>"
1145                "<label for=\"ln\">みょうじ</label>"
1146                " <input type=\"text\" id=\"ln\"><br>"
1147                "<label for=\"a1\">Address line 1:</label>"
1148                " <input type=\"text\" id=\"a1\"><br>"
1149                "<label for=\"a2\">Address line 2:</label>"
1150                " <input type=\"text\" id=\"a2\"><br>"
1151                "<label for=\"ci\">City:</label>"
1152                " <input type=\"text\" id=\"ci\"><br>"
1153                "<label for=\"st\">State:</label>"
1154                " <select id=\"st\">"
1155                " <option value=\"\" selected=\"yes\">--</option>"
1156                " <option value=\"CA\">California</option>"
1157                " <option value=\"TX\">Texas</option>"
1158                " </select><br>"
1159                "<label for=\"z\">ZIP code:</label>"
1160                " <input type=\"text\" id=\"z\"><br>"
1161                "<label for=\"co\">Country:</label>"
1162                " <select id=\"co\">"
1163                " <option value=\"\" selected=\"yes\">--</option>"
1164                " <option value=\"CA\">Canada</option>"
1165                " <option value=\"US\">United States</option>"
1166                " </select><br>"
1167                "<label for=\"ph\">Phone number:</label>"
1168                " <input type=\"text\" id=\"ph\"><br>"
1169                "</form>"
1170                // Add additional Japanese characters to ensure the translate bar
1171                // will appear.
1172                "我々は重要な、興味深いものになるが、時折状況が発生するため苦労や痛みは"
1173                "彼にいくつかの素晴らしいを調達することができます。それから、いくつかの利");
1174
1175   content::WindowedNotificationObserver infobar_observer(
1176       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
1177       content::NotificationService::AllSources());
1178   ASSERT_NO_FATAL_FAILURE(
1179       ui_test_utils::NavigateToURL(browser(), url));
1180
1181   // Wait for the translation bar to appear and get it.
1182   infobar_observer.Wait();
1183   InfoBarService* infobar_service =
1184       InfoBarService::FromWebContents(GetWebContents());
1185   translate::TranslateInfoBarDelegate* delegate =
1186       infobar_service->infobar_at(0)->delegate()->AsTranslateInfoBarDelegate();
1187   ASSERT_TRUE(delegate);
1188   EXPECT_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
1189             delegate->translate_step());
1190
1191   // Simulate translation button press.
1192   delegate->Translate();
1193
1194   content::WindowedNotificationObserver translation_observer(
1195       chrome::NOTIFICATION_PAGE_TRANSLATED,
1196       content::NotificationService::AllSources());
1197
1198   // Simulate the translate script being retrieved.
1199   // Pass fake google.translate lib as the translate script.
1200   SimulateURLFetch(true);
1201
1202   // Simulate the render notifying the translation has been done.
1203   translation_observer.Wait();
1204
1205   TryBasicFormFill();
1206 }
1207
1208 // Test phone fields parse correctly from a given profile.
1209 // The high level key presses execute the following: Select the first text
1210 // field, invoke the autofill popup list, select the first profile within the
1211 // list, and commit to the profile to populate the form.
1212 // Flakily times out on windows. http://crbug.com/390564
1213 #if defined(OS_WIN)
1214 #define MAYBE_ComparePhoneNumbers DISABLED_ComparePhoneNumbers
1215 #else
1216 #define MAYBE_ComparePhoneNumbers ComparePhoneNumbers
1217 #endif
1218 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, MAYBE_ComparePhoneNumbers) {
1219   ASSERT_TRUE(test_server()->Start());
1220
1221   AutofillProfile profile;
1222   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Bob"));
1223   profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Smith"));
1224   profile.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1234 H St."));
1225   profile.SetRawInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("San Jose"));
1226   profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
1227   profile.SetRawInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("95110"));
1228   profile.SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("1-408-555-4567"));
1229   SetProfile(profile);
1230
1231   GURL url = test_server()->GetURL("files/autofill/form_phones.html");
1232   ui_test_utils::NavigateToURL(browser(), url);
1233   PopulateForm("NAME_FIRST");
1234
1235   ExpectFieldValue("NAME_FIRST", "Bob");
1236   ExpectFieldValue("NAME_LAST", "Smith");
1237   ExpectFieldValue("ADDRESS_HOME_LINE1", "1234 H St.");
1238   ExpectFieldValue("ADDRESS_HOME_CITY", "San Jose");
1239   ExpectFieldValue("ADDRESS_HOME_STATE", "CA");
1240   ExpectFieldValue("ADDRESS_HOME_ZIP", "95110");
1241   ExpectFieldValue("PHONE_HOME_WHOLE_NUMBER", "14085554567");
1242   ExpectFieldValue("PHONE_HOME_CITY_CODE-1", "408");
1243   ExpectFieldValue("PHONE_HOME_CITY_CODE-2", "408");
1244   ExpectFieldValue("PHONE_HOME_NUMBER", "5554567");
1245   ExpectFieldValue("PHONE_HOME_NUMBER_3-1", "555");
1246   ExpectFieldValue("PHONE_HOME_NUMBER_3-2", "555");
1247   ExpectFieldValue("PHONE_HOME_NUMBER_4-1", "4567");
1248   ExpectFieldValue("PHONE_HOME_NUMBER_4-2", "4567");
1249   ExpectFieldValue("PHONE_HOME_EXT-1", std::string());
1250   ExpectFieldValue("PHONE_HOME_EXT-2", std::string());
1251   ExpectFieldValue("PHONE_HOME_COUNTRY_CODE-1", "1");
1252 }
1253
1254 // Test that Autofill does not fill in read-only fields.
1255 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, NoAutofillForReadOnlyFields) {
1256   ASSERT_TRUE(test_server()->Start());
1257
1258   std::string addr_line1("1234 H St.");
1259
1260   AutofillProfile profile;
1261   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Bob"));
1262   profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Smith"));
1263   profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("bsmith@gmail.com"));
1264   profile.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16(addr_line1));
1265   profile.SetRawInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("San Jose"));
1266   profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
1267   profile.SetRawInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("95110"));
1268   profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Company X"));
1269   profile.SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("408-871-4567"));
1270   SetProfile(profile);
1271
1272   GURL url = test_server()->GetURL("files/autofill/read_only_field_test.html");
1273   ui_test_utils::NavigateToURL(browser(), url);
1274   PopulateForm("firstname");
1275
1276   ExpectFieldValue("email", std::string());
1277   ExpectFieldValue("address", addr_line1);
1278 }
1279
1280 // Test form is fillable from a profile after form was reset.
1281 // Steps:
1282 //   1. Fill form using a saved profile.
1283 //   2. Reset the form.
1284 //   3. Fill form using a saved profile.
1285 // Flakily times out: http://crbug.com/270341
1286 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, DISABLED_FormFillableOnReset) {
1287   ASSERT_TRUE(test_server()->Start());
1288
1289   CreateTestProfile();
1290
1291   GURL url = test_server()->GetURL("files/autofill/autofill_test_form.html");
1292   ui_test_utils::NavigateToURL(browser(), url);
1293   PopulateForm("NAME_FIRST");
1294
1295   ASSERT_TRUE(content::ExecuteScript(
1296        GetWebContents(), "document.getElementById('testform').reset()"));
1297
1298   PopulateForm("NAME_FIRST");
1299
1300   ExpectFieldValue("NAME_FIRST", "Milton");
1301   ExpectFieldValue("NAME_LAST", "Waddams");
1302   ExpectFieldValue("EMAIL_ADDRESS", "red.swingline@initech.com");
1303   ExpectFieldValue("ADDRESS_HOME_LINE1", "4120 Freidrich Lane");
1304   ExpectFieldValue("ADDRESS_HOME_CITY", "Austin");
1305   ExpectFieldValue("ADDRESS_HOME_STATE", "Texas");
1306   ExpectFieldValue("ADDRESS_HOME_ZIP", "78744");
1307   ExpectFieldValue("ADDRESS_HOME_COUNTRY", "United States");
1308   ExpectFieldValue("PHONE_HOME_WHOLE_NUMBER", "5125551234");
1309 }
1310
1311 // Test Autofill distinguishes a middle initial in a name.
1312 // Flakily times out: http://crbug.com/270341
1313 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest,
1314                        DISABLED_DistinguishMiddleInitialWithinName) {
1315   ASSERT_TRUE(test_server()->Start());
1316
1317   CreateTestProfile();
1318
1319   GURL url = test_server()->GetURL(
1320       "files/autofill/autofill_middleinit_form.html");
1321   ui_test_utils::NavigateToURL(browser(), url);
1322   PopulateForm("NAME_FIRST");
1323
1324   ExpectFieldValue("NAME_MIDDLE", "C");
1325 }
1326
1327 // Test forms with multiple email addresses are filled properly.
1328 // Entire form should be filled with one user gesture.
1329 // Flakily times out: http://crbug.com/270341
1330 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest,
1331                        DISABLED_MultipleEmailFilledByOneUserGesture) {
1332   ASSERT_TRUE(test_server()->Start());
1333
1334   std::string email("bsmith@gmail.com");
1335
1336   AutofillProfile profile;
1337   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Bob"));
1338   profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Smith"));
1339   profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16(email));
1340   profile.SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("4088714567"));
1341   SetProfile(profile);
1342
1343   GURL url = test_server()->GetURL(
1344       "files/autofill/autofill_confirmemail_form.html");
1345   ui_test_utils::NavigateToURL(browser(), url);
1346   PopulateForm("NAME_FIRST");
1347
1348   ExpectFieldValue("EMAIL_CONFIRM", email);
1349   // TODO(isherman): verify entire form.
1350 }
1351
1352 // http://crbug.com/281527
1353 #if defined(OS_MACOSX)
1354 #define MAYBE_FormFillLatencyAfterSubmit FormFillLatencyAfterSubmit
1355 #else
1356 #define MAYBE_FormFillLatencyAfterSubmit DISABLED_FormFillLatencyAfterSubmit
1357 #endif
1358 // Test latency time on form submit with lots of stored Autofill profiles.
1359 // This test verifies when a profile is selected from the Autofill dictionary
1360 // that consists of thousands of profiles, the form does not hang after being
1361 // submitted.
1362 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest,
1363                        MAYBE_FormFillLatencyAfterSubmit) {
1364   ASSERT_TRUE(test_server()->Start());
1365
1366   std::vector<std::string> cities;
1367   cities.push_back("San Jose");
1368   cities.push_back("San Francisco");
1369   cities.push_back("Sacramento");
1370   cities.push_back("Los Angeles");
1371
1372   std::vector<std::string> streets;
1373   streets.push_back("St");
1374   streets.push_back("Ave");
1375   streets.push_back("Ln");
1376   streets.push_back("Ct");
1377
1378   const int kNumProfiles = 1500;
1379   base::Time start_time = base::Time::Now();
1380   std::vector<AutofillProfile> profiles;
1381   for (int i = 0; i < kNumProfiles; i++) {
1382     AutofillProfile profile;
1383     base::string16 name(base::IntToString16(i));
1384     base::string16 email(name + ASCIIToUTF16("@example.com"));
1385     base::string16 street = ASCIIToUTF16(
1386         base::IntToString(base::RandInt(0, 10000)) + " " +
1387         streets[base::RandInt(0, streets.size() - 1)]);
1388     base::string16 city =
1389         ASCIIToUTF16(cities[base::RandInt(0, cities.size() - 1)]);
1390     base::string16 zip(base::IntToString16(base::RandInt(0, 10000)));
1391     profile.SetRawInfo(NAME_FIRST, name);
1392     profile.SetRawInfo(EMAIL_ADDRESS, email);
1393     profile.SetRawInfo(ADDRESS_HOME_LINE1, street);
1394     profile.SetRawInfo(ADDRESS_HOME_CITY, city);
1395     profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
1396     profile.SetRawInfo(ADDRESS_HOME_ZIP, zip);
1397     profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
1398     profiles.push_back(profile);
1399   }
1400   SetProfiles(&profiles);
1401   // TODO(isherman): once we're sure this test doesn't timeout on any bots, this
1402   // can be removd.
1403   LOG(INFO) << "Created " << kNumProfiles << " profiles in " <<
1404                (base::Time::Now() - start_time).InSeconds() << " seconds.";
1405
1406   GURL url = test_server()->GetURL(
1407       "files/autofill/latency_after_submit_test.html");
1408   ui_test_utils::NavigateToURL(browser(), url);
1409   PopulateForm("NAME_FIRST");
1410
1411   content::WindowedNotificationObserver load_stop_observer(
1412       content::NOTIFICATION_LOAD_STOP,
1413       content::Source<content::NavigationController>(
1414           &GetWebContents()->GetController()));
1415
1416   ASSERT_TRUE(content::ExecuteScript(
1417       GetRenderViewHost(),
1418       "document.getElementById('testform').submit();"));
1419   // This will ensure the test didn't hang.
1420   load_stop_observer.Wait();
1421 }
1422
1423 // Test that Chrome doesn't crash when autocomplete is disabled while the user
1424 // is interacting with the form.  This is a regression test for
1425 // http://crbug.com/160476
1426 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest,
1427                        DisableAutocompleteWhileFilling) {
1428   CreateTestProfile();
1429
1430   // Load the test page.
1431   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
1432       GURL(std::string(kDataURIPrefix) + kTestFormString)));
1433
1434   // Invoke Autofill: Start filling the first name field with "M" and wait for
1435   // the popup to be shown.
1436   FocusFirstNameField();
1437   SendKeyToPageAndWait(ui::VKEY_M);
1438
1439   // Now that the popup with suggestions is showing, disable autocomplete for
1440   // the active field.
1441   ASSERT_TRUE(content::ExecuteScript(
1442       GetRenderViewHost(),
1443       "document.querySelector('input').autocomplete = 'off';"));
1444
1445   // Press the down arrow to select the suggestion and attempt to preview the
1446   // autofilled form.
1447   SendKeyToPopupAndWait(ui::VKEY_DOWN);
1448 }
1449
1450 }  // namespace autofill