[Autofill/Autocomplete Feature] Substring matching instead of prefix matching.

components/autofill/content/renderer/password_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/password_autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/content/renderer/renderer_save_password_progress_logger.h"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "components/autofill/core/common/autofill_switches.h"
+#include "components/autofill/core/common/autofill_util.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_form_fill_data.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebAutofillClient.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
@@ skipping 188 matching lines @@
 
 bool IsElementEditable(const blink::WebInputElement& element) {
   return element.isEnabled() && !element.isReadOnly();
 }
 
 bool DoUsernamesMatch(const base::string16& username1,
                       const base::string16& username2,
                       bool exact_match) {
   if (exact_match)
     return username1 == username2;
-  return base::StartsWith(username1, username2, base::CompareCase::SENSITIVE);
+  return base::StartsWith(username1, username2, base::CompareCase::SENSITIVE) ||

[vabr (Chromium), 2015/07/09 06:17:51]

I understand that the StartsWith call is there in case when
IsFeatureSubstringMatchEnabled returns false (because otherwise the test is
duplicated in ContainsTokenThatStartsWith). I'm not happy about the duplication,
and about the need to think about removing it once substring matching becomes
100% launched. So I suggest to change ContainsTokenThatStartsWith to try
matching from the begin every time, and from other token boundaries depending on
IsFeatureSubstringMatchEnabled. Then you can delete StartsWith here completely.

[Pritam Nikam, 2015/07/10 16:58:45]

For autofill & CC suggestions we are using base::StartsWith(...) and
ContainsTokenThatStartsWith(...) to identify suggestions with PREFIX or
SUBSTRING matched so that we can order them. IMO, if we move
base::StartsWith(...) to ContainsTokenThatStartsWith(...) it would be difficult
to do so by just making a single call to ContainsTokenThatStartsWith(...). To
keep the API usage consistent across, let this be as it is.

[vabr (Chromium), 2015/07/13 14:04:25]

I don't understand what you mean.
FieldIsSuggestionSubstringStartingOnTokenBoundary already does prefix matching,
as a particular case of the substring matching. You can still call StartsWith
elsewhere first to check if there is a prefix match, as you do now. Here there
is no need to distinguish prefix and non-prefix matches (no ranking based on
it), so there is no need to call StartsWith. Except for
FieldIsSuggestionSubstringStartingOnTokenBoundary no doing any matching when
substring is not allowed. I don't see how this is about consistency in API
usage. Consistent API usage does not mean that everybody using the API will
compute the same thing. I don't agree with letting this be as it is for the
"consistency" argument.

[Pritam Nikam, 2015/07/14 10:30:07]

Done.

+         ContainsTokenThatStartsWith(username1, username2, true);
 }
 
 // Returns |true| if the given element is editable. Otherwise, returns |false|.
 bool IsElementAutocompletable(const blink::WebInputElement& element) {
   return IsElementEditable(element);
 }
 
 // Returns true if the password specified in |form| is a default value.
 bool PasswordValueIsDefault(const base::string16& password_element,
                             const base::string16& password_value,
@@ skipping 171 matching lines @@
   }
   if (password.empty())
     return other_possible_username_selected;  // No match was found.
 
   // TODO(tkent): Check maxlength and pattern for both username and password
   // fields.
 
   // Input matches the username, fill in required values.
   if (!username_element->isNull() &&
       IsElementAutocompletable(*username_element)) {
     username_element->setValue(username, true);

[vabr (Chromium), 2015/07/09 08:27:50]

Please add:
// TODO(vabr): Why not setSuggestedValue? http://crbug.com/507714

[Pritam Nikam, 2015/07/10 16:58:46]

Done.

     nonscript_modified_values[*username_element] = username;
     username_element->setAutofilled(true);
-
-    if (set_selection) {
-      username_element->setSelectionRange(current_username.length(),
-                                          username.length());
-    }
+    if (set_selection)
+      PreviewSuggestion(username, current_username, username_element);
   } else if (current_username != username) {
     // If the username can't be filled and it doesn't match a saved password
     // as is, don't autofill a password.
     return other_possible_username_selected;
   }
 
   // Wait to fill in the password until a user gesture occurs. This is to make
   // sure that we do not fill in the DOM with a password until we believe the
   // user is intentionally interacting with the page.
   password_element->setSuggestedValue(password);
@@ skipping 126 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, public:
 
 PasswordAutofillAgent::PasswordAutofillAgent(content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
       legacy_(render_frame->GetRenderView(), this),
       usernames_usage_(NOTHING_TO_AUTOFILL),
       logging_state_active_(false),
       was_username_autofilled_(false),
       was_password_autofilled_(false),
-      username_selection_start_(0),
       did_stop_loading_(false),
       weak_ptr_factory_(this) {
   Send(new AutofillHostMsg_PasswordAutofillAgentConstructed(routing_id()));
 }
 
 PasswordAutofillAgent::~PasswordAutofillAgent() {
 }
 
 PasswordAutofillAgent::PasswordValueGatekeeper::PasswordValueGatekeeper()
     : was_user_gesture_seen_(false) {
@@ skipping 206 matching lines @@
     const blink::WebString& password) {
   blink::WebInputElement username_element;
   PasswordInfo* password_info;
 
   if (!FindLoginInfo(node, &username_element, &password_info) ||
       !IsElementAutocompletable(username_element) ||
       !IsElementAutocompletable(password_info->password_field)) {
     return false;
   }
 
+  if (username_query_prefix_.empty())
+    username_query_prefix_ = username_element.value();
+
   was_username_autofilled_ = username_element.isAutofilled();
-  username_selection_start_ = username_element.selectionStart();
   username_element.setSuggestedValue(username);
   username_element.setAutofilled(true);
-  username_element.setSelectionRange(
-      username_selection_start_,
-      username_element.suggestedValue().length());
-
+  ::autofill::PreviewSuggestion(username_element.suggestedValue(),
+                                username_query_prefix_, &username_element);
   was_password_autofilled_ = password_info->password_field.isAutofilled();
   password_info->password_field.setSuggestedValue(password);
   password_info->password_field.setAutofilled(true);
 
   return true;
 }
 
 bool PasswordAutofillAgent::DidClearAutofillSelection(
     const blink::WebNode& node) {
   blink::WebInputElement username_element;
@@ skipping 542 matching lines @@
     options |= SHOW_ALL;
   if (show_on_password_field)
     options |= IS_PASSWORD_FIELD;
   base::string16 username_string(
       username.isNull() ? base::string16()
                         : static_cast<base::string16>(user_input.value()));
   Send(new AutofillHostMsg_ShowPasswordSuggestions(
       routing_id(), key_it->second, field.text_direction, username_string,
       options, bounding_box_scaled));
 
+  username_query_prefix_ = username_string;
   bool suggestions_present = false;
   if (GetSuggestionsStats(fill_data, username_string, show_all,
                           &suggestions_present)) {
     usernames_usage_ = OTHER_POSSIBLE_USERNAME_SHOWN;
   }
   return suggestions_present;
 }
 
 void PasswordAutofillAgent::PerformInlineAutocomplete(
     const blink::WebInputElement& username_input,
@@ skipping 57 matching lines @@
   return FindPasswordInfoForElement(*found_input, &username_element,
                                     found_password);
 }
 
 void PasswordAutofillAgent::ClearPreview(
     blink::WebInputElement* username,
     blink::WebInputElement* password) {
   if (!username->suggestedValue().isEmpty()) {
     username->setSuggestedValue(blink::WebString());
     username->setAutofilled(was_username_autofilled_);
-    username->setSelectionRange(username_selection_start_,
+    username->setSelectionRange(username_query_prefix_.length(),
                                 username->value().length());
   }
   if (!password->suggestedValue().isEmpty()) {
       password->setSuggestedValue(blink::WebString());
       password->setAutofilled(was_password_autofilled_);
   }
 }
 
 void PasswordAutofillAgent::ProvisionallySavePassword(
     const blink::WebFormElement& form,
@@ skipping 38 matching lines @@
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::DidStopLoading() {
   agent_->DidStopLoading();
 }
 
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::
     DidStartProvisionalLoad(blink::WebLocalFrame* navigated_frame) {
   agent_->LegacyDidStartProvisionalLoad(navigated_frame);
 }
 
 }  // namespace autofill