Convert autofill messages to use the new IPC macros (again).

chrome/renderer/autofill/form_manager.cc

 // Copyright (c) 2010 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_manager.h"
 
 #include "base/logging.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
 #include "base/stl_util-inl.h"
@@ skipping 316 matching lines @@
 void FormManager::WebFormControlElementToFormField(
     const WebFormControlElement& element,
     ExtractMask extract_mask,
     FormField* 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->set_name(element.nameForAutofill());
-  field->set_form_control_type(element.formControlType());
+  field->name = element.nameForAutofill();
+  field->form_control_type = element.formControlType();
 
   if (!IsAutoFillableElement(element))
     return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
   if (IsTextInput(input_element)) {
-    field->set_max_length(input_element->maxLength());
-    field->set_autofilled(input_element->isAutofilled());
+    field->max_length = input_element->maxLength();
+    field->is_autofilled = input_element->isAutofilled();
   } else if (extract_mask & EXTRACT_OPTIONS) {
     // Set option strings on the field if available.
     DCHECK(IsSelectElement(element));
     const WebSelectElement select_element = element.toConst<WebSelectElement>();
     std::vector<string16> option_strings;
     GetOptionStringsFromElement(select_element, &option_strings);
-    field->set_option_strings(option_strings);
+    field->option_strings = option_strings;
   }
 
   if (!(extract_mask & EXTRACT_VALUE))
     return;
 
   string16 value;
   if (IsTextInput(input_element)) {
     value = input_element->value();
   } else {
     DCHECK(IsSelectElement(element));
@@ skipping 16 matching lines @@
     }
   }
 
   // TODO(jhawkins): This is a temporary stop-gap measure designed to prevent
   // a malicious site from DOS'ing the browser with extremely large profile
   // data.  The correct solution is to parse this data asynchronously.
   // See http://crbug.com/49332.
   if (value.size() > kMaxDataLength)
     value = value.substr(0, kMaxDataLength);
 
-  field->set_value(value);
+  field->value = value;
 }
 
 // static
 string16 FormManager::LabelForElement(const WebFormControlElement& element) {
   // Don't scrape labels for elements we can't possibly autofill anyway.
   if (!IsAutoFillableElement(element))
     return string16();
 
   WebNodeList labels = element.document().getElementsByTagName("label");
   for (unsigned i = 0; i < labels.length(); ++i) {
@@ skipping 60 matching lines @@
     if (requirements & REQUIRE_ENABLED && !control_element.isEnabled())
       continue;
 
     // Create a new FormField, fill it out and map it to the field's name.
     FormField* field = new FormField;
     WebFormControlElementToFormField(control_element, extract_mask, field);
     form_fields.push_back(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[field->name()] = field;
+    name_map[field->name] = field;
     fields_extracted[i] = true;
   }
 
   // Don't extract field labels if we have no fields.
   if (form_fields.empty())
     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
   // label.firstChild().nodeValue() of the label element.
   WebNodeList labels = 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>();
     if (field_element.isNull() ||
         !field_element.isFormControlElement() ||
         field_element.formControlType() == WebString::fromUTF8("hidden"))
       continue;
 
     std::map<string16, FormField*>::iterator iter =
         name_map.find(field_element.nameForAutofill());
     if (iter != name_map.end())
-      iter->second->set_label(FindChildText(label));
+      iter->second->label = FindChildText(label);
   }
 
   // Loop through the form control elements, extracting the label text from the
   // DOM.  We use the |fields_extracted| vector to make sure we assign the
   // extracted label to the correct field, as it's possible |form_fields| will
   // not contain all of the elements in |control_elements|.
   for (size_t i = 0, field_idx = 0;
        i < control_elements.size() && field_idx < form_fields.size(); ++i) {
     // This field didn't meet the requirements, so don't try to find a label for
     // it.
     if (!fields_extracted[i])
       continue;
 
     const WebFormControlElement& control_element = control_elements[i];
-    if (form_fields[field_idx]->label().empty())
-      form_fields[field_idx]->set_label(InferLabelForElement(control_element));
+    if (form_fields[field_idx]->label.empty())
+      form_fields[field_idx]->label = InferLabelForElement(control_element);
 
     ++field_idx;
   }
 
   // Copy the created FormFields into the resulting FormData object.
   for (ScopedVector<FormField>::const_iterator iter = form_fields.begin();
        iter != form_fields.end(); ++iter) {
     form->fields.push_back(**iter);
   }
 
@@ skipping 302 matching lines @@
   // one case in the wild where this happens, paypal.com signup form, the fields
   // are appended to the end of the form and are not visible.
   for (size_t i = 0, j = 0;
        i < form->control_elements.size() && j < data.fields.size();
        ++i) {
     WebFormControlElement* element = &form->control_elements[i];
     string16 element_name(element->nameForAutofill());
 
     // Search forward in the |form| for a corresponding field.
     size_t k = j;
-    while (k < data.fields.size() && element_name != data.fields[k].name())
+    while (k < data.fields.size() && element_name != data.fields[k].name)
       k++;
 
     if (k >= data.fields.size())
       continue;
 
-    DCHECK_EQ(data.fields[k].name(), element_name);
+    DCHECK_EQ(data.fields[k].name, element_name);
 
     bool is_initiating_node = false;
 
     // More than likely |requirements| will contain REQUIRE_AUTOCOMPLETE and/or
     // REQUIRE_EMPTY, which both require text form control elements, so special-
     // case this type of element.
     const WebInputElement* input_element = toWebInputElement(element);
     if (IsTextInput(input_element)) {
 
       // TODO(jhawkins): WebKit currently doesn't handle the autocomplete
@@ skipping 20 matching lines @@
     ++j;
   }
 
   delete callback;
 }
 
 void FormManager::FillFormField(WebFormControlElement* field,
                                 const FormField* data,
                                 bool is_initiating_node) {
   // Nothing to fill.
-  if (data->value().empty())
+  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()));
+        data->value.substr(0, input_element->maxLength()));
     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>();
-    select_element.setValue(data->value());
+    select_element.setValue(data->value);
   }
 }
 
 void FormManager::PreviewFormField(WebFormControlElement* field,
                                    const FormField* data,
                                    bool is_initiating_node) {
   // Nothing to preview.
-  if (data->value().empty())
+  if (data->value.empty())
     return;
 
   // Only preview input fields.
   WebInputElement* input_element = toWebInputElement(field);
   if (!IsTextInput(input_element))
     return;
 
   // If the maxlength attribute contains a negative value, maxLength()
   // returns the default maxlength value.
   input_element->setSuggestedValue(
-      data->value().substr(0, input_element->maxLength()));
+      data->value.substr(0, input_element->maxLength()));
   input_element->setAutofilled(true);
   if (is_initiating_node) {
     // Select the part of the text that the user didn't type.
     input_element->setSelectionRange(input_element->value().length(),
                                      input_element->suggestedValue().length());
   }
 }
 
 }  // namespace autofill