Move forms/ out of webkit/.

chrome/renderer/autofill/form_autofill_util.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/form_autofill_util.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/common/form_data.h"
+#include "chrome/common/form_field_data.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/WebFormControlElement.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/WebInputElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebLabelElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNodeList.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebOptionElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSelectElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
-#include "webkit/forms/form_data.h"
-#include "webkit/forms/form_field.h"
 
 using WebKit::WebElement;
 using WebKit::WebFormControlElement;
 using WebKit::WebFormElement;
 using WebKit::WebFrame;
 using WebKit::WebInputElement;
 using WebKit::WebLabelElement;
 using WebKit::WebNode;
 using WebKit::WebNodeList;
 using WebKit::WebOptionElement;
 using WebKit::WebSelectElement;
 using WebKit::WebString;
 using WebKit::WebVector;
-using webkit::forms::FormData;
-using webkit::forms::FormField;
 
 namespace {
 
 using autofill::ExtractAutofillableElements;
 using autofill::IsTextInput;
 using autofill::IsSelectElement;
 
 // The maximum length allowed for form data.
 const size_t kMaxDataLength = 1024;
 
@@ skipping 356 matching lines @@
     if (IsOptionElement(list_items[i])) {
       const WebOptionElement option = list_items[i].toConst<WebOptionElement>();
       option_values->push_back(option.value());
       option_contents->push_back(option.text());
     }
   }
 }
 
 // The callback type used by |ForEachMatchingFormField()|.
 typedef void (*Callback)(WebKit::WebFormControlElement*,
-                         const webkit::forms::FormField*,
+                         const FormFieldData*,
                          bool);
 
 // For each autofillable field in |data| that matches a field in the |form|,
 // the |callback| is invoked with the corresponding |form| field data.
 void ForEachMatchingFormField(const WebFormElement& form_element,
                               const WebElement& initiating_element,
                               const FormData& data,
                               Callback callback) {
   std::vector<WebFormControlElement> control_elements;
   ExtractAutofillableElements(form_element, autofill::REQUIRE_AUTOCOMPLETE,
@@ skipping 41 matching lines @@
         !element->isFocusable())
       continue;
 
     callback(element, &data.fields[i], is_initiating_element);
   }
 }
 
 // Sets the |field|'s value to the value in |data|.
 // Also sets the "autofilled" attribute, causing the background to be yellow.
 void FillFormField(WebKit::WebFormControlElement* field,
-                   const webkit::forms::FormField* data,
+                   const FormFieldData* data,
                    bool is_initiating_node) {
   // Nothing to fill.
   if (data->value.empty())
     return;
 
   WebInputElement* input_element = toWebInputElement(field);
   if (IsTextInput(input_element)) {
     // If the maxlength attribute contains a negative value, maxLength()
     // returns the default maxlength value.
     input_element->setValue(
         data->value.substr(0, input_element->maxLength()), true);
     input_element->setAutofilled(true);
     if (is_initiating_node) {
       int length = input_element->value().length();
       input_element->setSelectionRange(length, length);
     }
   } else {
     DCHECK(IsSelectElement(*field));
     WebSelectElement select_element = field->to<WebSelectElement>();
     if (select_element.value() != data->value) {
       select_element.setValue(data->value);
       select_element.dispatchFormControlChangeEvent();
     }
   }
 }
 
 // Sets the |field|'s "suggested" (non JS visible) value to the value in |data|.
 // Also sets the "autofilled" attribute, causing the background to be yellow.
 void PreviewFormField(WebKit::WebFormControlElement* field,
-                      const webkit::forms::FormField* data,
+                      const FormFieldData* data,
                       bool is_initiating_node) {
   // Nothing to preview.
   if (data->value.empty())
     return;
 
   // Only preview input fields.
   WebInputElement* input_element = toWebInputElement(field);
   if (!IsTextInput(input_element))
     return;
 
@@ skipping 58 matching lines @@
       if (IsTextInput(input_element) && !input_element->autoComplete())
         continue;
     }
 
     autofillable_elements->push_back(element);
   }
 }
 
 void WebFormControlElementToFormField(const WebFormControlElement& element,
                                       ExtractMask extract_mask,
-                                      FormField* field) {
+                                      FormFieldData* field) {
   DCHECK(field);
   DCHECK(!element.isNull());
 
   // The label is not officially part of a WebFormControlElement; however, the
   // labels for all form control elements are scraped from the DOM and set in
   // WebFormElementToFormData.
   field->name = element.nameForAutofill();
   field->form_control_type = element.formControlType();
   field->autocomplete_type = element.getAttribute("x-autocompletetype");
   TrimWhitespace(field->autocomplete_type, TRIM_ALL, &field->autocomplete_type);
@@ skipping 55 matching lines @@
     value = value.substr(0, kMaxDataLength);
 
   field->value = value;
 }
 
 bool WebFormElementToFormData(
     const WebKit::WebFormElement& form_element,
     const WebKit::WebFormControlElement& form_control_element,
     RequirementsMask requirements,
     ExtractMask extract_mask,
-    webkit::forms::FormData* form,
-    webkit::forms::FormField* field) {
+    FormData* form,
+    FormFieldData* field) {
   const WebFrame* frame = form_element.document().frame();
   if (!frame)
     return false;
 
   if (requirements & REQUIRE_AUTOCOMPLETE && !form_element.autoComplete())
     return false;
 
   form->name = GetFormIdentifier(form_element);
   form->method = form_element.method();
   form->origin = frame->document().url();
   form->action = frame->document().completeURL(form_element.action());
   form->user_submitted = form_element.wasUserSubmitted();
 
   // If the completed URL is not valid, just use the action we get from
   // WebKit.
   if (!form->action.is_valid())
     form->action = GURL(form_element.action());
 
-  // A map from a FormField's name to the FormField itself.
-  std::map<string16, FormField*> name_map;
+  // A map from a FormFieldData's name to the FormFieldData itself.
+  std::map<string16, FormFieldData*> name_map;
 
   // The extracted FormFields.  We use pointers so we can store them in
   // |name_map|.
-  ScopedVector<FormField> form_fields;
+  ScopedVector<FormFieldData> form_fields;
 
   WebVector<WebFormControlElement> control_elements;
   form_element.getFormControlElements(control_elements);
 
   // A vector of bools that indicate whether each field in the form meets the
   // requirements and thus will be in the resulting |form|.
   std::vector<bool> fields_extracted(control_elements.size(), false);
 
   for (size_t i = 0; i < control_elements.size(); ++i) {
     const WebFormControlElement& control_element = control_elements[i];
 
     if (!IsAutofillableElement(control_element))
       continue;
 
     const WebInputElement* input_element = toWebInputElement(&control_element);
     if (requirements & REQUIRE_AUTOCOMPLETE && IsTextInput(input_element) &&
         !input_element->autoComplete())
       continue;
 
-    // Create a new FormField, fill it out and map it to the field's name.
-    FormField* form_field = new FormField;
+    // Create a new FormFieldData, fill it out and map it to the field's name.
+    FormFieldData* form_field = new FormFieldData;
     WebFormControlElementToFormField(control_element, extract_mask, form_field);
     form_fields.push_back(form_field);
     // TODO(jhawkins): A label element is mapped to a form control element's id.
     // field->name() will contain the id only if the name does not exist.  Add
     // an id() method to WebFormControlElement and use that here.
     name_map[form_field->name] = form_field;
     fields_extracted[i] = true;
   }
 
   // If we failed to extract any fields, give up.  Also, to avoid overly
   // expensive computation, we impose a maximum number of allowable fields.
   if (form_fields.empty() || form_fields.size() > kMaxParseableFields)
     return false;
 
   // Loop through the label elements inside the form element.  For each label
   // element, get the corresponding form control element, use the form control
-  // element's name as a key into the <name, FormField> map to find the
-  // previously created FormField and set the FormField's label to the
+  // element's name as a key into the <name, FormFieldData> map to find the
+  // previously created FormFieldData and set the FormFieldData's label to the
   // label.firstChild().nodeValue() of the label element.
   WebNodeList labels = form_element.getElementsByTagName("label");
   for (unsigned i = 0; i < labels.length(); ++i) {
     WebLabelElement label = labels.item(i).to<WebLabelElement>();
     WebFormControlElement field_element =
         label.correspondingControl().to<WebFormControlElement>();
 
     string16 element_name;
     if (field_element.isNull()) {
       // Sometimes site authors will incorrectly specify the corresponding
       // field element's name rather than its id, so we compensate here.
       element_name = label.getAttribute("for");
     } else if (
         !field_element.isFormControlElement() ||
         field_element.formControlType() == WebString::fromUTF8("hidden")) {
       continue;
     } else {
       element_name = field_element.nameForAutofill();
     }
 
-    std::map<string16, FormField*>::iterator iter = name_map.find(element_name);
+    std::map<string16, FormFieldData*>::iterator iter =
+        name_map.find(element_name);
     if (iter != name_map.end()) {
       string16 label_text = FindChildText(label);
 
       // Concatenate labels because some sites might have multiple label
       // candidates.
       if (!iter->second->label.empty() && !label_text.empty())
         iter->second->label += ASCIIToUTF16(" ");
       iter->second->label += label_text;
     }
   }
@@ skipping 13 matching lines @@
     if (form_fields[field_idx]->label.empty())
       form_fields[field_idx]->label = InferLabelForElement(control_element);
 
     if (field && form_control_element == control_element)
       *field = *form_fields[field_idx];
 
     ++field_idx;
   }
 
   // Copy the created FormFields into the resulting FormData object.
-  for (ScopedVector<FormField>::const_iterator iter = form_fields.begin();
+  for (ScopedVector<FormFieldData>::const_iterator iter = form_fields.begin();
        iter != form_fields.end(); ++iter) {
     form->fields.push_back(**iter);
   }
 
   return true;
 }
 
 bool FindFormAndFieldForInputElement(const WebInputElement& element,
                                      FormData* form,
-                                     webkit::forms::FormField* field,
+                                     FormFieldData* field,
                                      RequirementsMask requirements) {
   if (!IsAutofillableElement(element))
     return false;
 
   const WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   ExtractMask extract_mask =
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
@@ skipping 89 matching lines @@
       continue;
 
     if (input_element->isAutofilled())
       return true;
   }
 
   return false;
 }
 
 }  // namespace autofill