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 211 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()),
       logging_state_active_(false),
+      was_username_autofilled_(false),
+      was_password_autofilled_(false),
       weak_ptr_factory_(this) {
 }
 
 PasswordAutofillAgent::~PasswordAutofillAgent() {
 }
 
 PasswordAutofillAgent::PasswordValueGatekeeper::PasswordValueGatekeeper()
     : was_user_gesture_seen_(false) {
 }
 
@@ skipping 18 matching lines @@
   }
 
   elements_.clear();
 }
 
 void PasswordAutofillAgent::PasswordValueGatekeeper::Reset() {
   was_user_gesture_seen_ = false;
   elements_.clear();
 }
 
+bool PasswordAutofillAgent::ClearPreviewForTest(
+    blink::WebInputElement* username,
+    blink::WebInputElement* password) {
+  return ClearPreview(username, password);
+}
+
 void PasswordAutofillAgent::PasswordValueGatekeeper::ShowValue(
     blink::WebInputElement* element) {
   if (!element->isNull() && !element->suggestedValue().isNull())
     element->setValue(element->suggestedValue(), true);
 }
 
 bool PasswordAutofillAgent::TextFieldDidEndEditing(
     const blink::WebInputElement& element) {
   LoginToPasswordInfoMap::const_iterator iter =
       login_to_password_info_.find(element);
@@ skipping 80 matching lines @@
   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::AcceptSuggestion(
+bool PasswordAutofillAgent::FillSuggestion(
     const blink::WebNode& node,
     const blink::WebString& username,
     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;
   }
 
   base::string16 current_username = username_element.value();
   username_element.setValue(username, true);
   username_element.setAutofilled(true);
   username_element.setSelectionRange(username.length(), username.length());
 
   password_info.password_field.setValue(password, true);
   password_info.password_field.setAutofilled(true);
 
   return true;
 }
 
+bool PasswordAutofillAgent::PreviewSuggestion(
+    const blink::WebNode& node,
+    const blink::WebString& username,
+    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;
+  }
+
+  was_username_autofilled_ = username_element.isAutofilled();
+  username_element.setSuggestedValue(username);
+  username_element.setAutofilled(true);
+  // Selection range starts from  the end of matching characters between the
+  // value and sugggestedValue of the username field.
+  std::string value_string = username_element.value().utf8();
+  std::string suggested_string = username_element.suggestedValue().utf8();
+  size_t selection_start = 0;
+  bool done_compare = false;
+  while (done_compare == false) {
+    if (selection_start == value_string.length() ||
+        selection_start == suggested_string.length())
+      done_compare = true;
+
+    if (value_string[selection_start] == suggested_string[selection_start])
+      selection_start++;
+    else
+      done_compare = true;
+  }
+  username_element.setSelectionRange(
+      selection_start,
+      username_element.suggestedValue().length());
+
+  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 input;
-  PasswordInfo password;
-  return FindLoginInfo(node, &input, &password);
+  blink::WebInputElement username_element;
+  PasswordInfo password_info;
+  if (!FindLoginInfo(node, &username_element, &password_info))
+    return false;
+
+  return ClearPreview(&username_element, &password_info.password_field);
 }
 
 bool PasswordAutofillAgent::ShowSuggestions(
     const blink::WebInputElement& element) {
   LoginToPasswordInfoMap::const_iterator iter =
       login_to_password_info_.find(element);
   if (iter == login_to_password_info_.end())
     return false;
 
   // If autocomplete='off' is set on the form elements, no suggestion dialog
@@ skipping 610 matching lines @@
   blink::WebInputElement input = element.to<blink::WebInputElement>();
   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;
 }
 
+bool PasswordAutofillAgent::ClearPreview(
+    blink::WebInputElement* username,
+    blink::WebInputElement* password) {
+  if (!username->suggestedValue().isEmpty()) {
+    username->setSuggestedValue(blink::WebString());
+    username->setAutofilled(was_username_autofilled_);
+    username->setSelectionRange(username->value().length(),
+                                username->value().length());
+  }
+  if (!password->suggestedValue().isEmpty()) {
+      password->setSuggestedValue(blink::WebString());
+      password->setAutofilled(was_password_autofilled_);
+  }
+
+  return true;

[Ilya Sherman, 2014/05/14 23:10:58]

Hmm, it looks like this method can only ever return true.  If so, it might as
well have a void return type instead.

[ziran.sun, 2014/05/15 12:36:37]

Done.

+}
+
 }  // namespace autofill