Basic autofill into password value on user gesture only.

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 171 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()),
+      gesture_handler_(new AutofillWebUserGestureHandler(this)),
+      user_gesture_occurred_(false),
       weak_ptr_factory_(this) {
+  blink::WebUserGestureIndicator::setHandler(gesture_handler_.get());
 }
 
 PasswordAutofillAgent::~PasswordAutofillAgent() {
+  DCHECK(gesture_handler_.get());
+  blink::WebUserGestureIndicator::setHandler(NULL);
 }
 
 bool PasswordAutofillAgent::TextFieldDidEndEditing(
     const blink::WebInputElement& element) {
   LoginToPasswordInfoMap::const_iterator iter =
       login_to_password_info_.find(element);
   if (iter == login_to_password_info_.end())
     return false;
 
   const PasswordFormFillData& fill_data =
@@ skipping 279 matching lines @@
     blink::WebFrame* form_frame = CurrentOrChildFrameWithSavedForms(frame);
     if (!blink::WebUserGestureIndicator::isProcessingUserGesture() &&
         provisionally_saved_forms_[form_frame].get()) {
       Send(new AutofillHostMsg_PasswordFormSubmitted(
           routing_id(),
           *provisionally_saved_forms_[form_frame]));
       provisionally_saved_forms_.erase(form_frame);
     }
     // Clear the whole map during main frame navigation.
     provisionally_saved_forms_.clear();
+
+    // We are navigating, se we need to wait for a new user gesture before
+    // filling in passwords.
+    user_gesture_occurred_ = false;
+    gesture_handler_->clearElements();
   }
 }
 
 void PasswordAutofillAgent::OnFillPasswordForm(
     const PasswordFormFillData& form_data) {
   if (usernames_usage_ == NOTHING_TO_AUTOFILL) {
     if (form_data.other_possible_usernames.size())
       usernames_usage_ = OTHER_POSSIBLE_USERNAMES_PRESENT;
     else if (usernames_usage_ == NOTHING_TO_AUTOFILL)
       usernames_usage_ = OTHER_POSSIBLE_USERNAMES_ABSENT;
@@ skipping 216 matching lines @@
     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;
   }
 
-  password_element->setValue(password);
+  // If a user gesture has not occurred, we setup a handler to listen for the
+  // next user gesture, at which point we then fill in the password. 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.
+  if (!user_gesture_occurred_) {
+    gesture_handler_->addElement(*password_element);
+    password_element->setSuggestedValue(password);
+  } else {
+    password_element->setValue(password);
+  }
   SetElementAutofilled(password_element, 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);
 
@@ skipping 52 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;
 }
 
+void PasswordAutofillAgent::AutofillWebUserGestureHandler::onGesture() {
+  agent_->set_user_gesture_occurred(true);
+
+  std::vector<blink::WebInputElement>::iterator iter;
+  for (iter = elements_.begin(); iter != elements_.end(); ++iter) {
+    if (!iter->isNull() && !iter->suggestedValue().isNull())
+      iter->setValue(iter->suggestedValue());
+  }
+
+  elements_.clear();
+}
+
+PasswordAutofillAgent::AutofillWebUserGestureHandler::
+    AutofillWebUserGestureHandler(PasswordAutofillAgent* agent)
+    : agent_(agent) {}
+
+PasswordAutofillAgent::AutofillWebUserGestureHandler::
+    ~AutofillWebUserGestureHandler() {}
+
 }  // namespace autofill