Add supports that allow Autofill to be initiated from textarea field

components/autofill/core/browser/autocomplete_history_manager_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
@@ skipping 207 matching lines @@
 
   MockAutofillExternalDelegate external_delegate(autofill_manager.get(),
                                                  autofill_driver_.get());
   autocomplete_history_manager.SetExternalDelegate(&external_delegate);
 
   // Should trigger a call to OnSuggestionsReturned, verified by the mock.
   EXPECT_CALL(external_delegate, OnSuggestionsReturned(_, _, _, _, _));
   autocomplete_history_manager.SendSuggestions(NULL);
 }
 
+// Verify that no autocomplete suggestion is returned for textarea.

[Ilya Sherman, 2014/03/20 22:22:03]

Hmm, where does the test verify that no suggestions were returned?  Am I just
overlooking something?

As a general thought: One good way to verify that a test is testing what you
intend for it to test is to temporarily revert the changes that are meant to fix
the test, and then run the test.  If it fails without the changes, that's good. 
If it still passes without the changes, then it's not really testing what you
mean for it to be testing.

[ziran.sun, 2014/03/21 12:00:22]

It's actually testing if autocomplete_history_manager.SendSuggestions(NULL) is
called for textarea. This will result in a call on
OnSuggestionReturned(_,_,_,_,_) with empty results in external_delegate.

[Ilya Sherman, 2014/03/21 23:01:11]

IMO the test would make more sense if the mock expectation were set to

  EXPECT_CALL(external_delegate,
              OnSuggestionsReturned(0,
                                    std::vector<base::string16>(),
                                    std::vector<base::string16>(),
                                    std::vector<base::string16>(),
                                    std::vector<int>()));

That way, the test will clearly fail if the returned values are non-empty, which
is what you're trying to test.  Currently, the test is just verifying that
OnSuggestionsReturned() is called at all... but it could be called with
non-empty values just as easily as with empty ones.

[ziran.sun, 2014/03/24 15:24:49]

Yes, this certainly makes sense. Just updated code as you suggested. Thanks very
much!

+TEST_F(AutocompleteHistoryManagerTest, TextArea) {

[Ilya Sherman, 2014/03/20 22:22:03]

nit: Please name this test "NoAutocompleteSuggestionsForTextarea".

[ziran.sun, 2014/03/21 12:00:22]

Done.

+  TestAutocompleteHistoryManager autocomplete_history_manager(
+      autofill_driver_.get(), manager_delegate_.get());
+
+  scoped_ptr<AutofillManager> autofill_manager(new AutofillManager(
+      autofill_driver_.get(),
+      manager_delegate_.get(),
+      "en-US",
+      AutofillManager::ENABLE_AUTOFILL_DOWNLOAD_MANAGER));
+
+  MockAutofillExternalDelegate external_delegate(autofill_manager.get(),
+                                                 autofill_driver_.get());
+  autocomplete_history_manager.SetExternalDelegate(&external_delegate);
+
+  FormData form;
+  form.name = ASCIIToUTF16("MyForm");
+  form.method = ASCIIToUTF16("POST");
+  form.origin = GURL("http://myform.com/form.html");
+  form.action = GURL("http://myform.com/submit.html");
+  form.user_submitted = true;
+
+  FormFieldData field;
+  test::CreateTestFormField("Address", "address", "", "textarea", &field);
+
+  EXPECT_CALL(external_delegate, OnSuggestionsReturned(_, _, _, _, _));
+  autocomplete_history_manager.OnGetAutocompleteSuggestions(
+      0,
+      field.name,
+      field.value,
+      field.form_control_type,
+      std::vector<base::string16>(),
+      std::vector<base::string16>(),
+      std::vector<base::string16>(),
+      std::vector<int>());
+}
+
 }  // namespace autofill