[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 FieldIsSuggestionSubstringStartingOnTokenBoundary(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 161 matching lines @@
   }
   if (password.empty())
     return false;
 
   // 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)) {
+    // TODO(vabr): Why not setSuggestedValue? http://crbug.com/507714
     username_element->setValue(username, true);
     (*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 false;
   }
 
   // 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 125 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, public:
 
 PasswordAutofillAgent::PasswordAutofillAgent(content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
       legacy_(render_frame->GetRenderView(), this),
       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 170 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 524 matching lines @@
   if (show_all)
     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;
   return CanShowSuggestion(fill_data, username_string, show_all);
 }
 
 void PasswordAutofillAgent::FrameClosing() {
   for (auto const& iter : login_to_password_info_) {
     login_to_password_info_key_.erase(iter.first);
     password_to_username_.erase(iter.second.password_field);
   }
   login_to_password_info_.clear();
   provisionally_saved_form_.reset();
@@ skipping 15 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