DataList UI (Chromium part)

chrome/renderer/autofill/autofill_agent.cc

 // Copyright (c) 2012 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 "chrome/renderer/autofill/autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/autofill_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/renderer/autofill/form_autofill_util.h"
 #include "chrome/renderer/autofill/password_autofill_manager.h"
 #include "content/public/renderer/render_view.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebDataListElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormControlElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebNodeCollection.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebOptionElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/forms/form_data.h"
 #include "webkit/forms/form_data_predictions.h"
 #include "webkit/forms/form_field.h"
 #include "webkit/forms/password_form.h"
 
+using WebKit::WebAutofillClient;
+using WebKit::WebDataListElement;
 using WebKit::WebFormControlElement;
 using WebKit::WebFormElement;
 using WebKit::WebFrame;
 using WebKit::WebInputElement;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebNode;
+using WebKit::WebNodeCollection;
+using WebKit::WebOptionElement;
 using WebKit::WebString;
 using webkit::forms::FormData;
 using webkit::forms::FormDataPredictions;
 
 namespace {
 
 // The size above which we stop triggering autofill for an input text field
 // (so to avoid sending long strings through IPC).
 const size_t kMaximumTextSizeForAutofill = 1000;
 
+void AppendDataListSuggestions(const WebKit::WebInputElement& element,
+                               std::vector<string16>* values,
+                               std::vector<string16>* labels,
+                               std::vector<string16>* icons,
+                               std::vector<int>* item_ids) {
+  WebDataListElement dataList = element.dataList();
+  if (dataList.isNull())
+    return;
+
+  WebNodeCollection options = dataList.options();
+  WebOptionElement option = options.firstItem().to<WebOptionElement>();
+  while (!option.isNull()) {
+    values->push_back(option.value());
+    if (option.value() != option.label())
+      labels->push_back(option.label());
+    else
+      labels->push_back(string16());
+    icons->push_back(string16());
+    item_ids->push_back(WebAutofillClient::DataListEntryMenuItemID);
+    option = options.nextItem().to<WebOptionElement>();
+  }
+}
+
 }  // namespace
 
 namespace autofill {
 
 AutofillAgent::AutofillAgent(
     content::RenderView* render_view,
     PasswordAutofillManager* password_autofill_manager)
     : content::RenderViewObserver(render_view),
       password_autofill_manager_(password_autofill_manager),
       autofill_query_id_(0),
       autofill_action_(AUTOFILL_NONE),
       display_warning_if_disabled_(false),
       was_query_node_autofilled_(false),
-      suggestions_clear_index_(-1),
-      suggestions_options_index_(-1),
       has_shown_autofill_popup_for_current_edit_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   render_view->GetWebView()->setAutofillClient(this);
 }
 
 AutofillAgent::~AutofillAgent() {}
 
 bool AutofillAgent::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AutofillAgent, message)
@@ skipping 66 matching lines @@
 
 bool AutofillAgent::InputElementLostFocus() {
   Send(new AutofillHostMsg_HideAutofillPopup(routing_id()));
 
   return false;
 }
 
 void AutofillAgent::didAcceptAutofillSuggestion(const WebNode& node,
                                                 const WebString& value,
                                                 const WebString& label,
-                                                int unique_id,
+                                                int item_id,
                                                 unsigned index) {
   if (password_autofill_manager_->DidAcceptAutofillSuggestion(node, value))
     return;
 
-  DCHECK(node == autofill_query_element_);
+  DCHECK(node == element_);
 
-  if (suggestions_options_index_ != -1 &&
-      index == static_cast<unsigned>(suggestions_options_index_)) {
-    // User selected 'Autofill Options'.
-    Send(new AutofillHostMsg_ShowAutofillDialog(routing_id()));
-  } else if (suggestions_clear_index_ != -1 &&
-             index == static_cast<unsigned>(suggestions_clear_index_)) {
-    // User selected 'Clear form'.
-    form_cache_.ClearFormWithElement(autofill_query_element_);
-  } else if (!unique_id) {
-    // User selected an Autocomplete entry, so we fill directly.
-    WebInputElement element = node.toConst<WebInputElement>();
-    SetNodeText(value, &element);
-  } else {
-    // Fill the values for the whole form.
-    FillAutofillFormData(node, unique_id, AUTOFILL_FILL);
+  switch (item_id) {
+    case WebAutofillClient::WarningMessageMenuItemID:
+    case WebAutofillClient::SeparatorMenuItemID:
+      NOTREACHED();
+      break;
+    case WebAutofillClient::AutofillOptionsMenuItemID:
+      // User selected 'Autofill Options'.
+      Send(new AutofillHostMsg_ShowAutofillDialog(routing_id()));
+      break;
+    case WebAutofillClient::ClearFormMenuItemID:
+      // User selected 'Clear form'.
+      form_cache_.ClearFormWithElement(element_);
+      break;
+    case WebAutofillClient::AutocompleteEntryMenuItemID:
+    case WebAutofillClient::PasswordEntryMenuItemID:
+    case WebAutofillClient::DataListEntryMenuItemID:
+      // User selected an Autocomplete or password or datalist entry, so we
+      // fill directly.
+      SetNodeText(value, &element_);
+      break;
+    default:
+      // A positive item_id is a unique id for an autofill (vs. autocomplete)
+      // suggestion.
+      DCHECK_GT(item_id, 0);
+      // Fill the values for the whole form.
+      FillAutofillFormData(node, item_id, AUTOFILL_FILL);
   }
-
-  suggestions_clear_index_ = -1;
-  suggestions_options_index_ = -1;
 }
 
 void AutofillAgent::didSelectAutofillSuggestion(const WebNode& node,
                                                 const WebString& value,
                                                 const WebString& label,
-                                                int unique_id) {
-  DCHECK_GE(unique_id, 0);
+                                                int item_id) {
   if (password_autofill_manager_->DidSelectAutofillSuggestion(node))
     return;
 
   didClearAutofillSelection(node);
-  FillAutofillFormData(node, unique_id, AUTOFILL_PREVIEW);
+
+  if (item_id > 0)
+    FillAutofillFormData(node, item_id, AUTOFILL_PREVIEW);
 }
 
 void AutofillAgent::didClearAutofillSelection(const WebNode& node) {
   if (password_autofill_manager_->DidClearAutofillSelection(node))
     return;
 
-  if (!autofill_query_element_.isNull() && node == autofill_query_element_) {
-    ClearPreviewedFormWithElement(autofill_query_element_,
-                                  was_query_node_autofilled_);
+  if (!element_.isNull() && node == element_) {
+    ClearPreviewedFormWithElement(element_, was_query_node_autofilled_);
   } else {
     // 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::removeAutocompleteSuggestion(const WebString& name,
                                                  const WebString& value) {
-  // The index of clear & options will have shifted down.
-  if (suggestions_clear_index_ != -1)
-    suggestions_clear_index_--;
-  if (suggestions_options_index_ != -1)
-    suggestions_options_index_--;
-
   Send(new AutofillHostMsg_RemoveAutocompleteEntry(routing_id(), name, value));
 }
 
 void AutofillAgent::textFieldDidEndEditing(const WebInputElement& element) {
   password_autofill_manager_->TextFieldDidEndEditing(element);
   has_shown_autofill_popup_for_current_edit_ = false;
   Send(new AutofillHostMsg_DidEndTextFieldEditing(routing_id()));
 }
 
 void AutofillAgent::textFieldDidChange(const WebInputElement& element) {
   // 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();
   MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&AutofillAgent::TextFieldDidChangeImpl,
                    weak_ptr_factory_.GetWeakPtr(), element));
 }
 
 void AutofillAgent::TextFieldDidChangeImpl(const WebInputElement& element) {
   if (password_autofill_manager_->TextDidChangeInTextField(element)) {
-    autofill_query_element_ = element;
+    element_ = element;
     return;
   }
 
   ShowSuggestions(element, false, true, false);
 
   webkit::forms::FormData form;
   webkit::forms::FormField field;
   if (FindFormAndFieldForInputElement(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_manager_->TextFieldHandlingKeyDown(element, event)) {
-    autofill_query_element_ = element;
+    element_ = element;
     return;
   }
 
   if (event.windowsKeyCode == ui::VKEY_DOWN ||
       event.windowsKeyCode == ui::VKEY_UP)
     ShowSuggestions(element, true, true, true);
 }
 
 void AutofillAgent::OnSuggestionsReturned(int query_id,
                                           const std::vector<string16>& values,
                                           const std::vector<string16>& labels,
                                           const std::vector<string16>& icons,
                                           const std::vector<int>& unique_ids) {
   WebKit::WebView* web_view = render_view()->GetWebView();
   if (!web_view || query_id != autofill_query_id_)
     return;

[Ilya Sherman, 2012/04/12 23:38:10]

nit: It looks like |web_view| is no longer used in this method; so let's remove
the variable from here, even though we can save a bit of work in the rare case
that it's somehow NULL.

[keishi, 2012/04/13 08:01:18]

Done.

 
-  if (values.empty()) {
-    // No suggestions, any popup currently showing is obsolete.
-    web_view->hidePopups();
-    return;
-  }
-
   std::vector<string16> v(values);
   std::vector<string16> l(labels);
   std::vector<string16> i(icons);
   std::vector<int> ids(unique_ids);
-  int separator_index = -1;
 
-  DCHECK_GT(ids.size(), 0U);
-  if (!autofill_query_element_.isNull() &&
-      !autofill_query_element_.autoComplete()) {
+  if (!element_.isNull() && !element_.autoComplete()) {
     // If autofill is disabled and we had suggestions, show a warning instead.

[Ilya Sherman, 2012/04/12 23:38:10]

The DCHECK_GT previously guaranteed that we had suggestions if we reached this
code.  It's now possible that we don't have any suggestions, in which case we
shouldn't show a warning.

[keishi, 2012/04/13 08:01:18]

Done.

     v.assign(1, l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_FORM_DISABLED));
     l.assign(1, string16());
     i.assign(1, string16());
-    ids.assign(1, -1);
-  } else if (ids[0] < 0 && ids.size() > 1) {
-    // If we received a warning instead of suggestions from autofill but regular
-    // suggestions from autocomplete, don't show the autofill warning.
+    ids.assign(1, WebAutofillClient::WarningMessageMenuItemID);
+  } else if (ids.size() > 1 &&
+             ids[0] == WebAutofillClient::WarningMessageMenuItemID) {
+    // If we received an autofill warning plus some autocomplete suggestions,
+    // remove the autofill warning.
     v.erase(v.begin());
     l.erase(l.begin());
     i.erase(i.begin());
     ids.erase(ids.begin());
   }
 
-  // If we were about to show a warning and we shouldn't, don't.
-  if (ids[0] < 0 && !display_warning_if_disabled_)
-    return;
-
   // Only include "Autofill Options" special menu item if we have Autofill
   // items, identified by |unique_ids| having at least one valid value.
   bool has_autofill_item = false;
+  bool has_warning_item = false;
   for (size_t i = 0; i < ids.size(); ++i) {
-    if (ids[i] > 0) {
+    if (ids[i] > 0)
       has_autofill_item = true;
-      break;
-    }
-  }
-
-  // The form has been auto-filled, so give the user the chance to clear the
-  // form.  Append the 'Clear form' menu item.
-  if (has_autofill_item &&
-      FormWithElementIsAutofilled(autofill_query_element_)) {
-    v.push_back(l10n_util::GetStringUTF16(IDS_AUTOFILL_CLEAR_FORM_MENU_ITEM));
-    l.push_back(string16());
-    i.push_back(string16());
-    ids.push_back(0);
-    suggestions_clear_index_ = v.size() - 1;
-    separator_index = v.size() - 1;
+    else if (ids[i] == WebAutofillClient::WarningMessageMenuItemID) {
+      has_warning_item = true;
+      if (has_autofill_item && has_warning_item)

[Ilya Sherman, 2012/04/12 23:38:10]

This case should be unreachable -- autofill items and warnings are mutually
exclusive.

[keishi, 2012/04/13 08:01:18]

Done.

+        break;
   }
 
   if (has_autofill_item) {
+    v.push_back(string16());
+    l.push_back(string16());
+    i.push_back(string16());
+    ids.push_back(WebAutofillClient::SeparatorMenuItemID);
+
+    if (FormWithElementIsAutofilled(element_)) {
+      // The form has been auto-filled, so give the user the chance to clear the
+      // form.  Append the 'Clear form' menu item.
+      v.push_back(l10n_util::GetStringUTF16(IDS_AUTOFILL_CLEAR_FORM_MENU_ITEM));
+      l.push_back(string16());
+      i.push_back(string16());
+      ids.push_back(WebAutofillClient::ClearFormMenuItemID);
+    }
+
     // Append the 'Chrome Autofill options' menu item;
     v.push_back(l10n_util::GetStringUTF16(IDS_AUTOFILL_OPTIONS_POPUP));
     l.push_back(string16());
     i.push_back(string16());
-    ids.push_back(0);
-    suggestions_options_index_ = v.size() - 1;
-    separator_index = values.size();
+    ids.push_back(WebAutofillClient::AutofillOptionsMenuItemID);
+  }
+
+  // If we were about to show a warning and we shouldn't, don't.
+  if (!display_warning_if_disabled_ && has_warning_item) {
+    v.clear();
+    l.clear();
+    i.clear();
+    ids.clear();
+  }

[Ilya Sherman, 2012/04/12 23:38:10]

I don't think you need to move this logic from where it was before.  I'm pretty
sure the warning is guaranteed to be the only item in the vector by the time we
were checking for it; and it should be safe to just clear all the vectors rather
than returning early.

[keishi, 2012/04/13 08:01:18]

Done.

+
+  if (!element_.isNull() && element_.isFocusable())
+    CombineDataListEntriesAndShow(element_, v, l, i, ids, has_autofill_item);
+}
+
+void AutofillAgent::CombineDataListEntriesAndShow(
+    const WebKit::WebInputElement& element,
+    const std::vector<string16>& values,
+    const std::vector<string16>& labels,
+    const std::vector<string16>& icons,
+    const std::vector<int>& item_ids,
+    bool has_autofill_item) {
+  std::vector<string16> v;
+  std::vector<string16> l;
+  std::vector<string16> i;
+  std::vector<int> ids;
+
+  AppendDataListSuggestions(element, &v, &l, &i, &ids);
+
+  // If there are both <datalist> items and Autofill suggestions, add a
+  // separator between them.
+  if (!v.empty() && !values.empty()) {
+    v.push_back(string16());
+    l.push_back(string16());
+    i.push_back(string16());
+    ids.push_back(WebAutofillClient::SeparatorMenuItemID);
+  }
+
+  v.insert(v.end(), values.begin(), values.end());
+  l.insert(l.end(), labels.begin(), labels.end());
+  i.insert(i.end(), icons.begin(), icons.end());
+  ids.insert(ids.end(), item_ids.begin(), item_ids.end());
+
+  WebKit::WebView* web_view = render_view()->GetWebView();
+  if (!web_view)
+    return;
+
+  if (v.empty()) {
+    // No suggestions, any popup currently showing is obsolete.
+    web_view->hidePopups();
+    return;
   }
 
   // Send to WebKit for display.
-  if (!v.empty() && !autofill_query_element_.isNull() &&
-      autofill_query_element_.isFocusable()) {
-    web_view->applyAutofillSuggestions(
-        autofill_query_element_, v, l, i, ids, separator_index);
-  }
+  web_view->applyAutofillSuggestions(element, v, l, i, ids);
 
   Send(new AutofillHostMsg_DidShowAutofillSuggestions(
       routing_id(),
       has_autofill_item && !has_shown_autofill_popup_for_current_edit_));
   has_shown_autofill_popup_for_current_edit_ |= has_autofill_item;
 }
 
 void AutofillAgent::OnFormDataFilled(int query_id,
                                      const webkit::forms::FormData& form) {
   if (!render_view()->GetWebView() || query_id != autofill_query_id_)
     return;
 
-  was_query_node_autofilled_ = autofill_query_element_.isAutofilled();
+  was_query_node_autofilled_ = element_.isAutofilled();
 
   switch (autofill_action_) {
     case AUTOFILL_FILL:
-      FillForm(form, autofill_query_element_);
+      FillForm(form, element_);
       Send(new AutofillHostMsg_DidFillAutofillFormData(routing_id(),
                                                        base::TimeTicks::Now()));
       break;
     case AUTOFILL_PREVIEW:
-      didClearAutofillSelection(autofill_query_element_);
+      didClearAutofillSelection(element_);
 
-      PreviewForm(form, autofill_query_element_);
+      PreviewForm(form, element_);
       Send(new AutofillHostMsg_DidPreviewAutofillFormData(routing_id()));
       break;
     default:
       NOTREACHED();
   }
   autofill_action_ = AUTOFILL_NONE;
 }
 
 void AutofillAgent::OnFieldTypePredictionsAvailable(
     const std::vector<FormDataPredictions>& forms) {
   for (size_t i = 0; i < forms.size(); ++i) {
     form_cache_.ShowPredictions(forms[i]);
   }
 }
 
 void AutofillAgent::OnSelectAutofillSuggestionAtIndex(int listIndex) {
   NOTIMPLEMENTED();
   // TODO(jrg): enable once changes land in WebKit
   // render_view()->webview()->selectAutofillSuggestionAtIndex(listIndex);
 }
 
 void AutofillAgent::OnSetAutofillActionFill() {
   autofill_action_ = AUTOFILL_FILL;
 }
 
 void AutofillAgent::OnClearForm() {
-  form_cache_.ClearFormWithElement(autofill_query_element_);
+  form_cache_.ClearFormWithElement(element_);
 }
 
 void AutofillAgent::OnSetAutofillActionPreview() {
   autofill_action_ = AUTOFILL_PREVIEW;
 }
 
 void AutofillAgent::OnClearPreviewedForm() {
-  didClearAutofillSelection(autofill_query_element_);
+  didClearAutofillSelection(element_);
 }
 
 void AutofillAgent::OnSetNodeText(const string16& value) {
-  SetNodeText(value, &autofill_query_element_);
+  SetNodeText(value, &element_);
 }
 
 void AutofillAgent::OnAcceptPasswordAutofillSuggestion(const string16& value) {
   // 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
   // isn't handled here then the browser logic needs to be updated.
   bool handled = password_autofill_manager_->DidAcceptAutofillSuggestion(
-      autofill_query_element_,
+      element_,
       value);
   DCHECK(handled);
 }
 
 void AutofillAgent::ShowSuggestions(const WebInputElement& element,
                                     bool autofill_on_empty_values,
                                     bool requires_caret_at_end,
                                     bool display_warning_if_disabled) {
-  // If autocomplete is disabled at the form level, then we might want to show
-  // a warning in place of suggestions. However, if autocomplete is disabled
-  // specifically for this field, we never want to show a warning. Otherwise,
-  // we might interfere with custom popups (e.g. search suggestions) used by
-  // the website.
-  const WebFormElement form = element.form();
-  if (!element.isEnabled() || element.isReadOnly() ||
-      (!element.autoComplete() && (form.isNull() || form.autoComplete())) ||
-      !element.isTextField() || element.isPasswordField() ||
-      !element.suggestedValue().isEmpty())
-    return;
-
-  // If the field has no name, then we won't have values.
-  if (element.nameForAutofill().isEmpty())
+  if (!element.isEnabled() || element.isReadOnly() || !element.isTextField() ||
+      element.isPasswordField() || !element.suggestedValue().isEmpty())
     return;
 
   // Don't attempt to autofill with values that are too large or if filling
   // criteria are not met.
   WebString value = element.value();
   if (value.length() > kMaximumTextSizeForAutofill ||
       (!autofill_on_empty_values && value.isEmpty()) ||
       (requires_caret_at_end &&
        (element.selectionStart() != element.selectionEnd() ||
         element.selectionEnd() != static_cast<int>(value.length())))) {
     // Any popup currently showing is obsolete.
     WebKit::WebView* web_view = render_view()->GetWebView();
     if (web_view)
       web_view->hidePopups();
 
     return;
   }
 
+  element_ = element;
+
+  // If autocomplete is disabled at the form level, then we might want to show
+  // a warning in place of suggestions. However, if autocomplete is disabled
+  // specifically for this field, we never want to show a warning. Otherwise,
+  // we might interfere with custom popups (e.g. search suggestions) used by
+  // the website. Also, if the field has no name, then we won't have values.
+  const WebFormElement form = element.form();
+  if ((!element.autoComplete() && (form.isNull() || form.autoComplete())) ||
+      element.nameForAutofill().isEmpty()) {
+    CombineDataListEntriesAndShow(element, std::vector<string16>(),
+                                  std::vector<string16>(),
+                                  std::vector<string16>(),
+                                  std::vector<int>(), false);
+    return;
+  }
+
   QueryAutofillSuggestions(element, display_warning_if_disabled);
 }
 
 void AutofillAgent::QueryAutofillSuggestions(const WebInputElement& element,
                                              bool display_warning_if_disabled) {
   static int query_counter = 0;
   autofill_query_id_ = query_counter++;
-  autofill_query_element_ = element;
   display_warning_if_disabled_ = display_warning_if_disabled;
 
   webkit::forms::FormData form;
   webkit::forms::FormField field;
   if (!FindFormAndFieldForInputElement(element, &form, &field,
                                        REQUIRE_AUTOCOMPLETE)) {
     // If we didn't find the cached form, at least let autocomplete have a shot
     // at providing suggestions.
     WebFormControlElementToFormField(element, EXTRACT_VALUE, &field);
   }
 
-  gfx::Rect bounding_box(autofill_query_element_.boundsInViewportSpace());
+  gfx::Rect bounding_box(element_.boundsInViewportSpace());
 
   Send(new AutofillHostMsg_QueryFormFieldAutofill(routing_id(),
                                                   autofill_query_id_,
                                                   form,
                                                   field,
                                                   bounding_box,
                                                   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++;
 
   webkit::forms::FormData form;
   webkit::forms::FormField field;
   if (!FindFormAndFieldForInputElement(node.toConst<WebInputElement>(), &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 string16& value,
                                 WebKit::WebInputElement* node) {
   string16 substring = value;
   substring = substring.substr(0, node->maxLength());
 
   node->setValue(substring, true);
 }
 
 }  // namespace autofill