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