Add Password Autofill Manager to New Autofill

chrome/renderer/autofill/password_autofill_manager.cc

 // Copyright (c) 2011 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 "chrome/renderer/autofill/password_autofill_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/common/autofill_messages.h"
+#include "chrome/renderer/autofill/form_autofill_util.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 #include "ui/base/keycodes/keyboard_codes.h"
@@ skipping 176 matching lines @@
 }  // namespace
 
 namespace autofill {
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillManager, public:
 
 PasswordAutofillManager::PasswordAutofillManager(
     content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
+      disable_popup_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 PasswordAutofillManager::~PasswordAutofillManager() {
 }
 
 bool PasswordAutofillManager::TextFieldDidEndEditing(
     const WebKit::WebInputElement& element) {
   LoginToPasswordInfoMap::const_iterator iter =
       login_to_password_info_.find(element);
@@ skipping 108 matching lines @@
   return FindLoginInfo(node, &input, &password);
 }
 
 bool PasswordAutofillManager::DidClearAutofillSelection(
     const WebKit::WebNode& node) {
   WebKit::WebInputElement input;
   PasswordInfo password;
   return FindLoginInfo(node, &input, &password);
 }
 
+void PasswordAutofillManager::HandleKeyDown(const WebKit::WebInputElement& node,
+                                            int key_code) {
+  LoginToPasswordInfoMap::iterator iter = login_to_password_info_.find(node);
+  if (iter == login_to_password_info_.end()) {
+    // The browser code should only send this message when it knows we have a
+    // match.
+    NOTREACHED();
+    return;
+  }
+
+  iter->second.backspace_pressed_last =
+      (key_code == ui::VKEY_BACK || key_code == ui::VKEY_DELETE);
+}
+
+void PasswordAutofillManager::DisablePopup() {
+  disable_popup_ = true;
+}
+
 void PasswordAutofillManager::SendPasswordForms(WebKit::WebFrame* frame,
                                                 bool only_visible) {
   // Make sure that this security origin is allowed to use password manager.
   WebKit::WebSecurityOrigin origin = frame->document().securityOrigin();
   if (!origin.canAccessPasswordManager())
     return;
 
   WebKit::WebVector<WebKit::WebFormElement> forms;
   frame->document().forms(forms);
 
@@ skipping 91 matching lines @@
     // We might have already filled this form if there are two <form> elements
     // with identical markup.
     if (login_to_password_info_.find(username_element) !=
         login_to_password_info_.end())
       continue;
 
     PasswordInfo password_info;
     password_info.fill_data = form_data;
     password_info.password_field = password_element;
     login_to_password_info_[username_element] = password_info;
+
+    webkit::forms::FormData form;
+    webkit::forms::FormField field;
+    FindFormAndFieldForInputElement(
+        username_element, &form, &field, REQUIRE_NONE);
+    Send(new AutofillHostMsg_FillPasswordForm(

[Ilya Sherman, 2012/03/08 23:22:14]

If I'm now understanding the code correctly, this message name is really
misleading.  This is actually telling the browser the mapping between the fields
on the page and the username/password combinations that correspond to them --
right?  Is that something we could do purely browser-side based on the FormsSeen
message, or do we need to bounce through the renderer to pick up extra info?

[csharp, 2012/03/09 16:20:19]

Yes. Changed the name to try and be a bit clearer. 

 Is that something we could do purely browser-side based on the FormsSeen
I don't think we stay just in the browser-side. The renderer code here gives the
elements that we are looking to fill in, and it can be a 1 to many mapping from
form_data to these elements, so I'm fairly certain we need to renderer.

Potentially we could just pass back the field and not the form_data, but then
we'd have to keep track of the form_data on the browser half and I think we'd be
introducing a potential race condition where we end up getting mismatched pairs.

[Ilya Sherman, 2012/03/09 22:00:26]

Ok.  The current approach should be fine -- I'm just a little worried about the
extra ping-ponging we're doing between the browser and renderer.  It might be
helpful to add a long-form comment somewhere describing the typical chain of
messages that get passed back and forth, so that it's a little easier for
someone unfamiliar with the code to get up to speed on how everything ties
together.

+        routing_id(),
+        field,
+        form_data,
+        username_element.document().frame()->identifier()));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillManager, private:
 
 void PasswordAutofillManager::GetSuggestions(
     const webkit::forms::PasswordFormFillData& fill_data,
     const string16& input,
     std::vector<string16>* suggestions) {
   if (StartsWith(fill_data.basic_data.fields[0].value, input, false))
     suggestions->push_back(fill_data.basic_data.fields[0].value);
 
   webkit::forms::PasswordFormFillData::LoginCollection::const_iterator iter;
   for (iter = fill_data.additional_logins.begin();
        iter != fill_data.additional_logins.end(); ++iter) {
     if (StartsWith(iter->first, input, false))
       suggestions->push_back(iter->first);
   }
 }
 
 bool PasswordAutofillManager::ShowSuggestionPopup(
     const webkit::forms::PasswordFormFillData& fill_data,
     const WebKit::WebInputElement& user_input) {
+  if (disable_popup_)
+    return false;
+
   WebKit::WebFrame* frame = user_input.document().frame();
   if (!frame)
     return false;
 
   WebKit::WebView* webview = frame->view();
   if (!webview)
     return false;
 
   std::vector<string16> suggestions;
   GetSuggestions(fill_data, user_input.value(), &suggestions);
@@ skipping 82 matching lines @@
 }
 
 void PasswordAutofillManager::FrameClosing(const WebKit::WebFrame* frame) {
   for (LoginToPasswordInfoMap::iterator iter = login_to_password_info_.begin();
        iter != login_to_password_info_.end();) {
     if (iter->first.document().frame() == frame)
       login_to_password_info_.erase(iter++);
     else
       ++iter;
   }
+
+  // Inform the Browser-side Password Manager of the closing frame.
+  Send(new AutofillHostMsg_FrameClosing(routing_id(), frame->identifier()));
 }
 
 bool PasswordAutofillManager::FindLoginInfo(
     const WebKit::WebNode& node,
     WebKit::WebInputElement* found_input,
     PasswordInfo* found_password) {
   if (!node.isElementNode())
     return false;
 
   WebKit::WebElement element = node.toConst<WebKit::WebElement>();
   if (!element.hasTagName("input"))
     return false;
 
   WebKit::WebInputElement input = element.to<WebKit::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;
 }
 
 }  // namespace autofill