Add "previewing on hover" support for password field.

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/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 200 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, public:
 
 PasswordAutofillAgent::PasswordAutofillAgent(content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
       usernames_usage_(NOTHING_TO_AUTOFILL),
       web_view_(render_view->GetWebView()),
+      was_password_autofilled_(false),
       weak_ptr_factory_(this) {
 }
 
 PasswordAutofillAgent::~PasswordAutofillAgent() {}
 
 PasswordAutofillAgent::PasswordValueGatekeeper::PasswordValueGatekeeper()
     : was_user_gesture_seen_(false) {}
 
 PasswordAutofillAgent::PasswordValueGatekeeper::~PasswordValueGatekeeper() {}
 
@@ skipping 96 matching lines @@
 
   // Don't attempt to autofill with values that are too large.
   if (element.value().length() > kMaximumTextSizeForAutocomplete)
     return false;
 
   // The caret position should have already been updated.
   PerformInlineAutocomplete(element, password, iter->second.fill_data);
   return true;
 }
 
+bool PasswordAutofillAgent::WasPasswordAutofilled() {
+  return was_password_autofilled_;
+}
+
 bool PasswordAutofillAgent::TextFieldHandlingKeyDown(
     const blink::WebInputElement& element,
     const blink::WebKeyboardEvent& event) {
   // If using the new Autofill UI that lives in the browser, it will handle
   // keypresses before this function. This is not currently an issue but if
   // the keys handled there or here change, this issue may appear.
 
   LoginToPasswordInfoMap::iterator iter = login_to_password_info_.find(element);
   if (iter == login_to_password_info_.end())
     return false;
 
   int win_key_code = event.windowsKeyCode;
   iter->second.backspace_pressed_last =
       (win_key_code == ui::VKEY_BACK || win_key_code == ui::VKEY_DELETE);
   return true;
 }
 
+bool PasswordAutofillAgent::DidSelectAutofillSuggestion(
+    const blink::WebNode& node,
+    const blink::WebString& username) {
+  blink::WebInputElement input;
+  PasswordInfo password;
+  if (!FindLoginInfo(node, &input, &password))
+    return false;
+
+  // Set the incoming |username| as the suggested value for the text field and
+  // |PreviewUserNameAndPassword| will do the rest.
+  input.setSuggestedValue(username);
+  return PreviewUserNameAndPassword(&input, &password.password_field,
+                                    password.fill_data,
+                                    true /* exact_username_match */,
+                                    true /* set_selection */);
+}
+
 bool PasswordAutofillAgent::DidAcceptAutofillSuggestion(
     const blink::WebNode& node,
     const blink::WebString& username) {
   blink::WebInputElement input;
   PasswordInfo password;
   if (!FindLoginInfo(node, &input, &password))
     return false;
 
   // Set the incoming |username| in the text field and |FillUserNameAndPassword|
   // will do the rest.
@@ skipping 379 matching lines @@
     username_element.setValue(fill_data.basic_data.fields[0].value, true);
   }
 
   // Fill if we have an exact match for the username. Note that this sets
   // username to autofilled.
   FillUserNameAndPassword(&username_element, &password_element, fill_data,
                           true /* exact_username_match */,
                           false /* set_selection */);
 }
 
-bool PasswordAutofillAgent::FillUserNameAndPassword(
-    blink::WebInputElement* username_element,
-    blink::WebInputElement* password_element,
+std::vector<base::string16> PasswordAutofillAgent::FindUserNameAndPassword(
+    base::string16 current_username,
     const PasswordFormFillData& fill_data,
-    bool exact_username_match,
-    bool set_selection) {
-  base::string16 current_username = username_element->value();
-  // username and password will contain the match found if any.
-  base::string16 username;
-  base::string16 password;
-
+    bool exact_username_match) {
+  std::vector<base::string16> username_and_password;

[Ilya Sherman, 2014/03/21 22:35:19]

Please use out-parameters named "string16* username" and "string16* password"
rather than returning a vector of two objects.

[ziran.sun, 2014/03/25 18:25:26]

Done.

   // Look for any suitable matches to current field text.
   if (DoUsernamesMatch(fill_data.basic_data.fields[0].value, current_username,
                        exact_username_match)) {
-    username = fill_data.basic_data.fields[0].value;
-    password = fill_data.basic_data.fields[1].value;
-  } else {
+    username_and_password.push_back(fill_data.basic_data.fields[0].value);
+    username_and_password.push_back(fill_data.basic_data.fields[1].value);
+  }  else {
     // Scan additional logins for a match.
     PasswordFormFillData::LoginCollection::const_iterator iter;
     for (iter = fill_data.additional_logins.begin();
          iter != fill_data.additional_logins.end(); ++iter) {
       if (DoUsernamesMatch(iter->first, current_username,
                            exact_username_match)) {
-        username = iter->first;
-        password = iter->second.password;
+        username_and_password.push_back(iter->first);
+        username_and_password.push_back(iter->second.password);
         break;
       }
     }
-
     // Check possible usernames.
-    if (username.empty() && password.empty()) {
+    if (username_and_password.size() == 0) {
       for (PasswordFormFillData::UsernamesCollection::const_iterator iter =
                fill_data.other_possible_usernames.begin();
            iter != fill_data.other_possible_usernames.end(); ++iter) {
         for (size_t i = 0; i < iter->second.size(); ++i) {
           if (DoUsernamesMatch(iter->second[i], current_username,
                                exact_username_match)) {
             usernames_usage_ = OTHER_POSSIBLE_USERNAME_SELECTED;
-            username = iter->second[i];
-            password = iter->first.password;
+            username_and_password.push_back(iter->second[i]);
+            username_and_password.push_back(iter->first.password);
             break;
           }
         }
-        if (!username.empty() && !password.empty())
+        if (username_and_password.size() == 2)
           break;
       }
     }
   }
-  if (password.empty())
+  return username_and_password;
+}
+
+bool PasswordAutofillAgent::FillUserNameAndPassword(
+    blink::WebInputElement* username_element,
+    blink::WebInputElement* password_element,
+    const PasswordFormFillData& fill_data,
+    bool exact_username_match,
+    bool set_selection) {
+  base::string16 current_username = username_element->value();
+  // username and password will contain the match found if any.
+  std::vector<base::string16> username_and_password =
+      FindUserNameAndPassword (current_username,
+                               fill_data,
+                               exact_username_match);
+
+  if(username_and_password.size() < 2)
     return false;  // No match was found.
 
+  // username and password contain the match found.
+  base::string16 username = username_and_password[0];
+  base::string16 password = username_and_password[1];
+
   // TODO(tkent): Check maxlength and pattern for both username and password
   // fields.
 
   // Don't fill username if password can't be set.
   if (!IsElementAutocompletable(*password_element)) {
     return false;
   }
 
   // Input matches the username, fill in required values.
   if (IsElementAutocompletable(*username_element)) {
     username_element->setValue(username, true);
     SetElementAutofilled(username_element, true);
 
     if (set_selection) {
       username_element->setSelectionRange(current_username.length(),
                                           username.length());
     }
   } 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;
   }
 
+  was_password_autofilled_ = password_element->isAutofilled();
 // TODO(vabr): The "gatekeeper" feature is currently disabled on mobile.
 // http://crbug.com/345510#c13
 #if !defined(OS_ANDROID) || !defined(OS_IOS)
   // 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);
   gatekeeper_.RegisterElement(password_element);
 #else
   password_element->setValue(password);
 #endif
 
   // Note: Don't call SetElementAutofilled() here, as that dispatches an
   // onChange event in JavaScript, which is not appropriate for the password
   // element if a user gesture has not yet occured.
   password_element->setAutofilled(true);
   return true;
 }
 
+bool PasswordAutofillAgent::PreviewUserNameAndPassword(
+    blink::WebInputElement* username_element,
+    blink::WebInputElement* password_element,
+    const PasswordFormFillData& fill_data,
+    bool exact_username_match,
+    bool set_selection) {
+  base::string16 current_username = username_element->suggestedValue();
+  std::vector<base::string16> username_and_password =
+      FindUserNameAndPassword (current_username,
+                               fill_data,
+                               exact_username_match);
+
+  if (username_and_password.size() < 2)
+    return false;  // No match was found.
+
+  // TODO(tkent): Check maxlength and pattern for both username and password
+  // fields.
+
+  // Don't preview username if password can't be set.
+  if (!IsElementAutocompletable(*password_element)) {
+    return false;
+  }
+
+  base::string16 username = username_and_password[0];
+  base::string16 password = username_and_password[1];
+
+  // Input matches the username, preview required values.
+  if (IsElementAutocompletable(*username_element)) {
+    username_element->setSuggestedValue(username);
+    username_element->setAutofilled(true);
+
+    if (set_selection) {
+      username_element->setSelectionRange(current_username.length(),
+                                          username.length());

[Ilya Sherman, 2014/03/21 22:35:19]

This will always set an empty selection, right?  The goal is to have the part of
the text that the user didn't type be selected.

[ziran.sun, 2014/03/25 18:25:26]

I tried to replace current_username.length() with
username_element->value().length() but it doesn't seems making any difference. I
will look into this further.

+    }
+  } else if (current_username != username) {
+    return false;
+  }
+
+  was_password_autofilled_ = password_element->isAutofilled();
+  password_element->setSuggestedValue(password);
+  password_element->setAutofilled(true);
+  return true;
+}
+
 void PasswordAutofillAgent::PerformInlineAutocomplete(
     const blink::WebInputElement& username_input,
     const blink::WebInputElement& password_input,
     const PasswordFormFillData& fill_data) {
   DCHECK(!fill_data.wait_for_username);
 
   // We need non-const versions of the username and password inputs.
   blink::WebInputElement username = username_input;
   blink::WebInputElement password = password_input;
 
@@ skipping 49 matching lines @@
   LoginToPasswordInfoMap::iterator iter = login_to_password_info_.find(input);
   if (iter == login_to_password_info_.end())
     return false;
 
   *found_input = input;
   *found_password = iter->second;
   return true;
 }
 
 }  // namespace autofill