Add supports that allow Autofill to be initiated from textarea field

components/autofill/content/renderer/autofill_agent.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 "components/autofill/content/renderer/autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
@@ skipping 23 matching lines @@
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElementCollection.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebOptionElement.h"
+#include "third_party/WebKit/public/web/WebTextAreaElement.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 using blink::WebAutofillClient;
+using blink::WebElementCollection;
 using blink::WebFormControlElement;
 using blink::WebFormElement;
 using blink::WebFrame;
 using blink::WebInputElement;
 using blink::WebKeyboardEvent;
 using blink::WebNode;
-using blink::WebElementCollection;
 using blink::WebOptionElement;
 using blink::WebString;
+using blink::WebTextAreaElement;
 
 namespace autofill {
 
 namespace {
 
 // Gets all the data list values (with corresponding label) for the given
 // element.
 void GetDataListSuggestions(const blink::WebInputElement& element,
                             bool ignore_current_value,
                             std::vector<base::string16>* values,
@@ skipping 212 matching lines @@
   HidePopup();
 
   in_flight_request_form_ = form;
   Send(new AutofillHostMsg_RequestAutocomplete(routing_id(), form_data, url));
 }
 
 void AutofillAgent::setIgnoreTextChanges(bool ignore) {
   ignore_text_changes_ = ignore;
 }
 
-void AutofillAgent::InputElementClicked(const WebInputElement& element,
-                                        bool was_focused,
-                                        bool is_focused) {
+void AutofillAgent::FormControlElementClicked(
+    const WebFormControlElement& element,
+    bool was_focused) {
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (!IsAutofillableInputElement(input_element) &&
+      !IsTextAreaElement(element))
+    return;
+
   if (was_focused)
     ShowSuggestions(element, true, false, true, false);
 }
 
-void AutofillAgent::InputElementLostFocus() {
+void AutofillAgent::FormControlElementLostFocus() {
   HidePopup();
 }
 
 void AutofillAgent::textFieldDidEndEditing(const WebInputElement& element) {
   password_autofill_agent_->TextFieldDidEndEditing(element);
   has_shown_autofill_popup_for_current_edit_ = false;
   Send(new AutofillHostMsg_DidEndTextFieldEditing(routing_id()));
 }
 
+// TODO(ziran.sun): This function is to be removed once next Blink roll is done
 void AutofillAgent::textFieldDidChange(const WebInputElement& element) {
+  const WebFormControlElement control_element =
+      element.toConst<WebFormControlElement>();
+  textFieldDidChange(control_element);
+}
+
+void AutofillAgent::textFieldDidChange(const WebFormControlElement& element) {
   if (ignore_text_changes_)
     return;
 
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (input_element)
+    DCHECK(IsAutofillableInputElement(input_element));
+  else
+    DCHECK(IsTextAreaElement(element));

[Ilya Sherman, 2014/03/01 02:50:53]

nit: You can shorten these five lines to

DCHECK(IsAutofillableElement(element) && !IsSelectElement(element));

or to

DCHECK(IsAutofillableInputElement(toWebInputElement(&element)) ||
       IsTextAreaElement(element));

[ziran.sun, 2014/03/03 19:23:32]

Done.

+
   if (did_set_node_text_) {
     did_set_node_text_ = false;
     return;
   }
 
   // We post a task for doing the Autofill as the caret position is not set
   // properly at this point (http://bugs.webkit.org/show_bug.cgi?id=16976) and
   // it is needed to trigger autofill.
   weak_ptr_factory_.InvalidateWeakPtrs();
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&AutofillAgent::TextFieldDidChangeImpl,
                  weak_ptr_factory_.GetWeakPtr(),
                  element));
 }
 
-void AutofillAgent::TextFieldDidChangeImpl(const WebInputElement& element) {
+void AutofillAgent::TextFieldDidChangeImpl(
+    const WebFormControlElement& element) {
   // If the element isn't focused then the changes don't matter. This check is
   // required to properly handle IME interactions.
   if (!element.focused())
     return;
 
-  if (password_generation_agent_ &&
-      password_generation_agent_->TextDidChangeInTextField(element)) {
-    return;
-  }
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (IsAutofillableInputElement(input_element)) {
+    if (password_generation_agent_ &&
+        password_generation_agent_->TextDidChangeInTextField(*input_element)) {
+      return;
+    }
 
-  if (password_autofill_agent_->TextDidChangeInTextField(element)) {
-    element_ = element;
-    return;
+    if (password_autofill_agent_->TextDidChangeInTextField(*input_element)) {
+      element_ = element;
+      return;
+    }
   }
 
   ShowSuggestions(element, false, true, false, false);
 
   FormData form;
   FormFieldData field;
-  if (FindFormAndFieldForInputElement(element, &form, &field, REQUIRE_NONE)) {
+  if (FindFormAndFieldForFormControlElement(element,
+                                            &form,
+                                            &field,
+                                            REQUIRE_NONE)) {
     Send(new AutofillHostMsg_TextFieldDidChange(routing_id(), form, field,
                                                 base::TimeTicks::Now()));
   }
 }
 
 void AutofillAgent::textFieldDidReceiveKeyDown(const WebInputElement& element,
                                                const WebKeyboardEvent& event) {
   if (password_autofill_agent_->TextFieldHandlingKeyDown(element, event)) {
     element_ = element;
     return;
   }
 
   if (event.windowsKeyCode == ui::VKEY_DOWN ||
       event.windowsKeyCode == ui::VKEY_UP)
     ShowSuggestions(element, true, true, true, false);
 }
 
 void AutofillAgent::openTextDataListChooser(const WebInputElement& element) {
     ShowSuggestions(element, true, false, false, true);
 }
 
 void AutofillAgent::AcceptDataListSuggestion(
     const base::string16& suggested_value) {
+  WebInputElement* input_element = toWebInputElement(&element_);
+  DCHECK(IsAutofillableInputElement(input_element));
   base::string16 new_value = suggested_value;
   // If this element takes multiple values then replace the last part with
   // the suggestion.
-  if (element_.isMultiple() &&
-      element_.formControlType() == WebString::fromUTF8("email")) {
+  if (input_element->isMultiple() &&
+      input_element->formControlType() == WebString::fromUTF8("email")) {
     std::vector<base::string16> parts;
 
-    base::SplitStringDontTrim(element_.editingValue(), ',', &parts);
+    base::SplitStringDontTrim(input_element->editingValue(), ',', &parts);
     if (parts.size() == 0)
       parts.push_back(base::string16());
 
     base::string16 last_part = parts.back();
     // We want to keep just the leading whitespace.
     for (size_t i = 0; i < last_part.size(); ++i) {
       if (!IsWhitespace(last_part[i])) {
         last_part = last_part.substr(0, i);
         break;
       }
     }
     last_part.append(suggested_value);
     parts[parts.size() - 1] = last_part;
 
     new_value = JoinString(parts, ',');
   }
-  SetNodeText(new_value, &element_);
+  SetNodeText(new_value, input_element);
 }
 
 void AutofillAgent::OnFormDataFilled(int query_id,
                                      const FormData& form) {
   if (!render_view()->GetWebView() || query_id != autofill_query_id_)
     return;
 
   was_query_node_autofilled_ = element_.isAutofilled();
 
   switch (autofill_action_) {
@@ skipping 41 matching lines @@
     // TODO(isherman): There seem to be rare cases where this code *is*
     // reachable: see [ http://crbug.com/96321#c6 ].  Ideally we would
     // understand those cases and fix the code to avoid them.  However, so far I
     // have been unable to reproduce such a case locally.  If you hit this
     // NOTREACHED(), please file a bug against me.
     NOTREACHED();
   }
 }
 
 void AutofillAgent::OnSetNodeText(const base::string16& value) {
-  SetNodeText(value, &element_);
+  WebInputElement* input_element = toWebInputElement(&element_);
+  DCHECK(IsAutofillableInputElement(input_element));
+
+  SetNodeText(value, input_element);
 }
 
 void AutofillAgent::OnAcceptDataListSuggestion(const base::string16& value) {
   AcceptDataListSuggestion(value);
 }
 
 void AutofillAgent::OnAcceptPasswordAutofillSuggestion(
     const base::string16& username) {
   // We need to make sure this is handled here because the browser process
   // skipped it handling because it believed it would be handled here. If it
@@ skipping 15 matching lines @@
       result = WebFormElement::AutocompleteResultErrorInvalid;
   }
 
   in_flight_request_form_.finishRequestAutocomplete(result);
   in_flight_request_form_.reset();
 }
 
 void AutofillAgent::OnPageShown() {
 }
 
-void AutofillAgent::ShowSuggestions(const WebInputElement& element,
+void AutofillAgent::ShowSuggestions(const WebFormControlElement& element,
                                     bool autofill_on_empty_values,
                                     bool requires_caret_at_end,
                                     bool display_warning_if_disabled,
                                     bool datalist_only) {
-  if (!element.isEnabled() || element.isReadOnly() || !element.isTextField() ||
-      element.isPasswordField())
-    return;
-  if (!datalist_only && !element.suggestedValue().isEmpty())
+  if (!element.isEnabled() || element.isReadOnly())
     return;
 
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (IsAutofillableInputElement(input_element)) {
+    if (!input_element->isTextField() || input_element->isPasswordField())
+      return;
+    if (!datalist_only && !input_element->suggestedValue().isEmpty())
+      return;
+  } else if (IsTextAreaElement(element)) {

[Ilya Sherman, 2014/03/01 02:50:53]

nit: Can this be a DCHECK rather than an if?

[ziran.sun, 2014/03/03 19:23:32]

Done.

+    if (!element.toConst<WebTextAreaElement>().suggestedValue().isEmpty())
+      return;
+  }
+
+  WebString value;
+  int selectionStart;
+  int selectionEnd;
+  if (IsAutofillableInputElement(input_element)) {
+    value = input_element->editingValue();
+    selectionStart = input_element->selectionStart();
+    selectionEnd = input_element->selectionEnd();
+  } else {
+    DCHECK(IsTextAreaElement(element));
+    const WebTextAreaElement textarea_element =
+        element.toConst<WebTextAreaElement>();
+    value = textarea_element.editingValue();
+    selectionStart = textarea_element.selectionStart();
+    selectionEnd = textarea_element.selectionEnd();
+  }
   // Don't attempt to autofill with values that are too large or if filling
   // criteria are not met.
-  WebString value = element.editingValue();
   if (!datalist_only &&
       (value.length() > kMaxDataLength ||
        (!autofill_on_empty_values && value.isEmpty()) ||
        (requires_caret_at_end &&
-        (element.selectionStart() != element.selectionEnd() ||
-         element.selectionEnd() != static_cast<int>(value.length()))))) {
+        (selectionStart != selectionEnd ||
+         selectionEnd != static_cast<int>(value.length()))))) {
     // Any popup currently showing is obsolete.
     HidePopup();
     return;
   }
 
   element_ = element;
-  if (password_autofill_agent_->ShowSuggestions(element)) {
-    is_popup_possibly_visible_ = true;
+  if (IsAutofillableInputElement(input_element) &&
+      password_autofill_agent_->ShowSuggestions(*input_element))

[Ilya Sherman, 2014/03/01 02:50:53]

Please preserve the line "is_popup_possibly_visible_ = true;"

[ziran.sun, 2014/03/03 19:23:32]

Done.

     return;
-  }
 
   // If autocomplete is disabled at the field level, ensure that the native
   // UI won't try to show a warning, since that may conflict with a custom
   // popup. Note that we cannot use the WebKit method element.autoComplete()
   // as it does not allow us to distinguish the case where autocomplete is
   // disabled for *both* the element and for the form.
   const base::string16 autocomplete_attribute =
       element.getAttribute("autocomplete");
   if (LowerCaseEqualsASCII(autocomplete_attribute, "off"))
     display_warning_if_disabled = false;
 
   QueryAutofillSuggestions(element,
                            display_warning_if_disabled,
                            datalist_only);
 }
 
-void AutofillAgent::QueryAutofillSuggestions(const WebInputElement& element,
-                                             bool display_warning_if_disabled,
-                                             bool datalist_only) {
+void AutofillAgent::QueryAutofillSuggestions(
+    const WebFormControlElement& element,
+    bool display_warning_if_disabled,
+    bool datalist_only) {
   if (!element.document().frame())
     return;
 
   static int query_counter = 0;
   autofill_query_id_ = query_counter++;
   display_warning_if_disabled_ = display_warning_if_disabled;
 
   // If autocomplete is disabled at the form level, we want to see if there
   // would have been any suggestions were it enabled, so that we can show a
   // warning.  Otherwise, we want to ignore fields that disable autocomplete, so
   // that the suggestions list does not include suggestions for these form
   // fields -- see comment 1 on http://crbug.com/69914
-  const RequirementsMask requirements =
-      element.autoComplete() ? REQUIRE_AUTOCOMPLETE : REQUIRE_NONE;
+  RequirementsMask requirements = REQUIRE_NONE;
+  const WebInputElement* input_element = toWebInputElement(&element);
+  if (IsAutofillableInputElement(input_element)) {
+    requirements =
+        input_element->autoComplete() ? REQUIRE_AUTOCOMPLETE : REQUIRE_NONE;
+  } else {
+    DCHECK(IsTextAreaElement(element));
+    const WebTextAreaElement textarea_element =
+        element.toConst<WebTextAreaElement>();
+    requirements =
+        textarea_element.autoComplete() ? REQUIRE_AUTOCOMPLETE : REQUIRE_NONE;
+  }
 
   FormData form;
   FormFieldData field;
-  if (!FindFormAndFieldForInputElement(element, &form, &field, requirements)) {
+  if (!FindFormAndFieldForFormControlElement(element, &form, &field,
+                                             requirements)) {
     // If we didn't find the cached form, at least let autocomplete have a shot
     // at providing suggestions.
     WebFormControlElementToFormField(element, EXTRACT_VALUE, &field);
   }
   if (datalist_only)
     field.should_autocomplete = false;
 
   gfx::RectF bounding_box_scaled =
       GetScaledBoundingBox(web_view_->pageScaleFactor(), &element_);
 
-  // Find the datalist values and send them to the browser process.
-  std::vector<base::string16> data_list_values;
-  std::vector<base::string16> data_list_labels;
-  GetDataListSuggestions(element_,
-                         datalist_only,
-                         &data_list_values,
-                         &data_list_labels);
-  TrimStringVectorForIPC(&data_list_values);
-  TrimStringVectorForIPC(&data_list_labels);
+  if (IsAutofillableInputElement(input_element)) {
+    // Find the datalist values and send them to the browser process.
+    std::vector<base::string16> data_list_values;
+    std::vector<base::string16> data_list_labels;
+    GetDataListSuggestions(*input_element,
+                           datalist_only,
+                           &data_list_values,
+                           &data_list_labels);
+    TrimStringVectorForIPC(&data_list_values);
+    TrimStringVectorForIPC(&data_list_labels);
+
+    Send(new AutofillHostMsg_SetDataList(routing_id(),
+                                         data_list_values,
+                                         data_list_labels));
+  }
 
   is_popup_possibly_visible_ = true;
-  Send(new AutofillHostMsg_SetDataList(routing_id(),
-                                       data_list_values,
-                                       data_list_labels));
-
   Send(new AutofillHostMsg_QueryFormFieldAutofill(routing_id(),
                                                   autofill_query_id_,
                                                   form,
                                                   field,
                                                   bounding_box_scaled,
                                                   display_warning_if_disabled));
 }
 
 void AutofillAgent::FillAutofillFormData(const WebNode& node,
                                          int unique_id,
                                          AutofillAction action) {
   DCHECK_GT(unique_id, 0);
 
   static int query_counter = 0;
   autofill_query_id_ = query_counter++;
 
   FormData form;
   FormFieldData field;
-  if (!FindFormAndFieldForInputElement(node.toConst<WebInputElement>(), &form,
-                                       &field, REQUIRE_AUTOCOMPLETE)) {
+  if (!FindFormAndFieldForFormControlElement(
+           node.toConst<WebFormControlElement>(),
+           &form,
+           &field,
+           REQUIRE_AUTOCOMPLETE)) {
     return;
   }
 
   autofill_action_ = action;
   Send(new AutofillHostMsg_FillAutofillFormData(
       routing_id(), autofill_query_id_, form, field, unique_id));
 }
 
 void AutofillAgent::SetNodeText(const base::string16& value,
                                 blink::WebInputElement* node) {
@@ skipping 20 matching lines @@
     // Only monitors dynamic forms created in the top frame. Dynamic forms
     // inserted in iframes are not captured yet.
     if (!frame->parent()) {
       password_autofill_agent_->OnDynamicFormsSeen(frame);
       return;
     }
   }
 }
 
 }  // namespace autofill