Move forms/ out of webkit/.

chrome/renderer/autofill/password_autofill_manager.cc

 // Copyright (c) 2012 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/common/password_form_fill_data.h"
 #include "chrome/renderer/autofill/form_autofill_util.h"
+#include "content/public/common/form_field.h"
+#include "content/public/common/password_form.h"
+#include "content/public/renderer/password_form_conversion_utils.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAutofillClient.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"
-#include "webkit/forms/form_field.h"
-#include "webkit/forms/password_form.h"
-#include "webkit/forms/password_form_dom_manager.h"
 
 namespace {
 
 // The size above which we stop triggering autocomplete.
 static const size_t kMaximumTextSizeForAutocomplete = 1000;
 
 // Maps element names to the actual elements to simplify form filling.
 typedef std::map<string16, WebKit::WebInputElement>
     FormInputElementMap;
 
 // Utility struct for form lookup and autofill. When we parse the DOM to look up
 // a form, in addition to action and origin URL's we have to compare all
 // necessary form elements. To avoid having to look these up again when we want
 // to fill the form, the FindFormElements function stores the pointers
 // in a FormElements* result, referenced to ensure they are safe to use.
 struct FormElements {
   WebKit::WebFormElement form_element;
   FormInputElementMap input_elements;
 };
 
 typedef std::vector<FormElements*> FormElementsList;
 
 // Helper to search the given form element for the specified input elements
 // in |data|, and add results to |result|.
 static bool FindFormInputElements(WebKit::WebFormElement* fe,
-                                  const webkit::forms::FormData& data,
+                                  const content::FormData& data,
                                   FormElements* result) {
   // Loop through the list of elements we need to find on the form in order to
   // autofill it. If we don't find any one of them, abort processing this
   // form; it can't be the right one.
   for (size_t j = 0; j < data.fields.size(); j++) {
     WebKit::WebVector<WebKit::WebNode> temp_elements;
     fe->getNamedElements(data.fields[j].name, temp_elements);
 
     // Match the first input element, if any.
     // |getNamedElements| may return non-input elements where the names match,
@@ skipping 27 matching lines @@
     if (!found_input) {
       result->input_elements.clear();
       return false;
     }
   }
   return true;
 }
 
 // Helper to locate form elements identified by |data|.
 void FindFormElements(WebKit::WebView* view,
-                      const webkit::forms::FormData& data,
+                      const content::FormData& data,
                       FormElementsList* results) {
   DCHECK(view);
   DCHECK(results);
   WebKit::WebFrame* main_frame = view->mainFrame();
   if (!main_frame)
     return;
 
   GURL::Replacements rep;
   rep.ClearQuery();
   rep.ClearRef();
@@ skipping 33 matching lines @@
       curr_elements->form_element = fe;
       results->push_back(curr_elements.release());
     }
   }
 }
 
 bool IsElementEditable(const WebKit::WebInputElement& element) {
   return element.isEnabled() && !element.isReadOnly();
 }
 
-void FillForm(FormElements* fe, const webkit::forms::FormData& data) {
+void FillForm(FormElements* fe, const content::FormData& data) {
   if (!fe->form_element.autoComplete())
     return;
 
   std::map<string16, string16> data_map;
   for (size_t i = 0; i < data.fields.size(); i++)
     data_map[data.fields[i].name] = data.fields[i].value;
 
   for (FormInputElementMap::iterator it = fe->input_elements.begin();
        it != fe->input_elements.end(); ++it) {
     WebKit::WebInputElement element = it->second;
@@ skipping 49 matching lines @@
 PasswordAutofillManager::~PasswordAutofillManager() {
 }
 
 bool PasswordAutofillManager::TextFieldDidEndEditing(
     const WebKit::WebInputElement& element) {
   LoginToPasswordInfoMap::const_iterator iter =
       login_to_password_info_.find(element);
   if (iter == login_to_password_info_.end())
     return false;
 
-  const webkit::forms::PasswordFormFillData& fill_data =
+  const chrome::PasswordFormFillData& fill_data =
       iter->second.fill_data;
 
   // If wait_for_username is false, we should have filled when the text changed.
   if (!fill_data.wait_for_username)
     return false;
 
   WebKit::WebInputElement password = iter->second.password_field;
   if (!IsElementEditable(password))
     return false;
 
@@ skipping 102 matching lines @@
 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);
 
-  std::vector<webkit::forms::PasswordForm> password_forms;
+  std::vector<content::PasswordForm> password_forms;
   for (size_t i = 0; i < forms.size(); ++i) {
     const WebKit::WebFormElement& form = forms[i];
 
     // Respect autocomplete=off.
     if (!form.autoComplete())
       continue;
 
     // If requested, ignore non-rendered forms, e.g. those styled with
     // display:none.
     if (only_visible && !form.hasNonEmptyBoundingBox())
       continue;
 
-    scoped_ptr<webkit::forms::PasswordForm> password_form(
-        webkit::forms::PasswordFormDomManager::CreatePasswordForm(form));
+    scoped_ptr<content::PasswordForm> password_form(
+        content::CreatePasswordForm(form));
     if (password_form.get())
       password_forms.push_back(*password_form);
   }
 
   if (password_forms.empty() && !only_visible) {
     // We need to send the PasswordFormsRendered message regardless of whether
     // there are any forms visible, as this is also the code path that triggers
     // showing the infobar.
     return;
   }
@@ skipping 48 matching lines @@
     bool is_focused) {
   // TODO(jcivelli): http://crbug.com/51644 Implement behavior.
   return false;
 }
 
 bool PasswordAutofillManager::InputElementLostFocus() {
   return false;
 }
 
 void PasswordAutofillManager::OnFillPasswordForm(
-    const webkit::forms::PasswordFormFillData& form_data,
+    const chrome::PasswordFormFillData& form_data,
     bool disable_popup) {
   disable_popup_ = disable_popup;
 
   FormElementsList forms;
   // We own the FormElements* in forms.
   FindFormElements(render_view()->GetWebView(), form_data.basic_data, &forms);
   FormElementsList::iterator iter;
   for (iter = forms.begin(); iter != forms.end(); ++iter) {
     scoped_ptr<FormElements> form_elements(*iter);
 
@@ skipping 16 matching lines @@
     // 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;
+    content::FormData form;
+    content::FormField field;
     FindFormAndFieldForInputElement(
         username_element, &form, &field, REQUIRE_NONE);
     Send(new AutofillHostMsg_AddPasswordFormMapping(
         routing_id(),
         field,
         form_data));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillManager, private:
 
 void PasswordAutofillManager::GetSuggestions(
-    const webkit::forms::PasswordFormFillData& fill_data,
+    const chrome::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;
+  chrome::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 chrome::PasswordFormFillData& fill_data,
     const WebKit::WebInputElement& user_input) {
   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);
 
   if (disable_popup_) {
-    webkit::forms::FormData form;
-    webkit::forms::FormField field;
+    content::FormData form;
+    content::FormField field;
     FindFormAndFieldForInputElement(
         user_input, &form, &field, REQUIRE_NONE);
 
     WebKit::WebInputElement selected_element = user_input;
     gfx::Rect bounding_box(selected_element.boundsInViewportSpace());
     Send(new AutofillHostMsg_ShowPasswordSuggestions(routing_id(),
                                                      field,
                                                      bounding_box,
                                                      suggestions));
     return !suggestions.empty();
@@ skipping 10 matching lines @@
   std::vector<int> ids(suggestions.size(),
                        WebKit::WebAutofillClient::MenuItemIDPasswordEntry);
   webview->applyAutofillSuggestions(
       user_input, suggestions, labels, icons, ids);
   return true;
 }
 
 bool PasswordAutofillManager::FillUserNameAndPassword(
     WebKit::WebInputElement* username_element,
     WebKit::WebInputElement* password_element,
-    const webkit::forms::PasswordFormFillData& fill_data,
+    const chrome::PasswordFormFillData& fill_data,
     bool exact_username_match,
     bool set_selection) {
   string16 current_username = username_element->value();
   // username and password will contain the match found if any.
   string16 username;
   string16 password;
 
   // 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 {
     // Scan additional logins for a match.
-    webkit::forms::PasswordFormFillData::LoginCollection::const_iterator iter;
+    chrome::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;
         break;
       }
     }
   }
@@ skipping 11 matching lines @@
   SetElementAutofilled(username_element, true);
   if (IsElementEditable(*password_element))
     password_element->setValue(password);
   SetElementAutofilled(password_element, true);
   return true;
 }
 
 void PasswordAutofillManager::PerformInlineAutocomplete(
     const WebKit::WebInputElement& username_input,
     const WebKit::WebInputElement& password_input,
-    const webkit::forms::PasswordFormFillData& fill_data) {
+    const chrome::PasswordFormFillData& fill_data) {
   DCHECK(!fill_data.wait_for_username);
 
   // We need non-const versions of the username and password inputs.
   WebKit::WebInputElement username = username_input;
   WebKit::WebInputElement password = password_input;
 
   // Don't inline autocomplete if the caret is not at the end.
   // TODO(jcivelli): is there a better way to test the caret location?
   if (username.selectionStart() != username.selectionEnd() ||
       username.selectionEnd() != static_cast<int>(username.value().length())) {
@@ skipping 32 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