Convert autofill messages to use the new IPC macros

chrome/browser/autofill/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/browser/autofill/autofill_manager.h"
 
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 175 matching lines @@
     while (k < form_structure->field_count() &&
            *form_structure->field(k) != form.fields[j]) {
       k++;
     }
 
     // If we didn't find a match, continue on to the next |form| field.
     if (k >= form_structure->field_count())
       continue;
 
     AutofillType autofill_type(form_structure->field(k)->type());
-    if (form.fields[j].is_autofilled())
+    if (form.fields[j].is_autofilled)
       return true;
 
     // We found a matching field in the |form_structure| so we
     // proceed to the next |form| field, and the next |form_structure|.
     ++i;
   }
 
   return false;
 }
 
@@ skipping 168 matching lines @@
 
         RemoveDuplicateSuggestions(&values, &labels, &icons, &unique_ids);
       }
     }
   }
 
   // Add the results from AutoComplete.  They come back asynchronously, so we
   // hand off what we generated and they will send the results back to the
   // renderer.
   tab_contents()->autocomplete_history_manager()->OnGetAutocompleteSuggestions(
-      query_id, field.name(), field.value(), values, labels, icons, unique_ids);
+      query_id, field.name, field.value, values, labels, icons, unique_ids);
 }
 
 void AutofillManager::OnFillAutoFillFormData(int query_id,
                                              const FormData& form,
                                              const FormField& field,
                                              int unique_id) {
   const std::vector<AutoFillProfile*>& profiles = personal_data_->profiles();
   const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards();
   RenderViewHost* host = NULL;
   FormStructure* form_structure = NULL;
@@ skipping 174 matching lines @@
   }
 
   return prefs->GetBoolean(prefs::kAutoFillEnabled);
 }
 
 void AutofillManager::DeterminePossibleFieldTypesForUpload(
     FormStructure* submitted_form) {
   for (size_t i = 0; i < submitted_form->field_count(); i++) {
     const AutofillField* field = submitted_form->field(i);
     FieldTypeSet field_types;
-    personal_data_->GetPossibleFieldTypes(field->value(), &field_types);
+    personal_data_->GetPossibleFieldTypes(field->value, &field_types);
 
     DCHECK(!field_types.empty());
     submitted_form->set_possible_types(i, field_types);
   }
 }
 
 void AutofillManager::LogMetricsAboutSubmittedForm(
     const FormData& form,
     const FormStructure* submitted_form) {
   FormStructure* cached_submitted_form;
   if (!FindCachedForm(form, &cached_submitted_form)) {
     NOTREACHED();
     return;
   }
 
   // Map from field signatures to cached fields.
   std::map<std::string, const AutofillField*> cached_fields;
   for (size_t i = 0; i < cached_submitted_form->field_count(); ++i) {
     const AutofillField* field = cached_submitted_form->field(i);
     cached_fields[field->FieldSignature()] = field;
   }
 
   std::string experiment_id = cached_submitted_form->server_experiment_id();
   for (size_t i = 0; i < submitted_form->field_count(); ++i) {
     const AutofillField* field = submitted_form->field(i);
     FieldTypeSet field_types;
-    personal_data_->GetPossibleFieldTypes(field->value(), &field_types);
+    personal_data_->GetPossibleFieldTypes(field->value, &field_types);
     DCHECK(!field_types.empty());
 
-    if (field->form_control_type() == ASCIIToUTF16("select-one")) {
-      // TODO(isherman): <select> fields don't support |is_autofilled()|. Since
+    if (field->form_control_type == ASCIIToUTF16("select-one")) {
+      // TODO(isherman): <select> fields don't support |is_autofilled|. Since
       // this is heavily relied upon by our metrics, we just don't log anything
       // for all <select> fields. Better to have less data than misleading data.
       continue;
     }
 
     // Log various quality metrics.
     metric_logger_->Log(AutofillMetrics::FIELD_SUBMITTED, experiment_id);
     if (field_types.find(EMPTY_TYPE) == field_types.end() &&
         field_types.find(UNKNOWN_TYPE) == field_types.end()) {
-      if (field->is_autofilled()) {
+      if (field->is_autofilled) {
         metric_logger_->Log(AutofillMetrics::FIELD_AUTOFILLED, experiment_id);
       } else {
         metric_logger_->Log(AutofillMetrics::FIELD_AUTOFILL_FAILED,
                             experiment_id);
 
         AutofillFieldType heuristic_type = UNKNOWN_TYPE;
         AutofillFieldType server_type = NO_SERVER_DATA;
         std::map<std::string, const AutofillField*>::const_iterator
             cached_field = cached_fields.find(field->FieldSignature());
         if (cached_field != cached_fields.end()) {
@@ skipping 178 matching lines @@
   const std::vector<AutoFillProfile*>& profiles = personal_data_->profiles();
   std::vector<AutoFillProfile*> matched_profiles;
   for (std::vector<AutoFillProfile*>::const_iterator iter = profiles.begin();
        iter != profiles.end(); ++iter) {
     AutoFillProfile* profile = *iter;
 
     // The value of the stored data for this field type in the |profile|.
     string16 profile_field_value = profile->GetFieldText(type);
 
     if (!profile_field_value.empty() &&
-        StartsWith(profile_field_value, field.value(), false)) {
+        StartsWith(profile_field_value, field.value, false)) {
       matched_profiles.push_back(profile);
       values->push_back(profile_field_value);
       unique_ids->push_back(PackGUIDs(std::string(), profile->guid()));
     }
   }
 
   std::vector<AutofillFieldType> form_fields;
   form_fields.reserve(form->field_count());
   for (std::vector<AutofillField*>::const_iterator iter = form->begin();
        iter != form->end(); ++iter) {
@@ skipping 19 matching lines @@
                                                std::vector<string16>* icons,
                                                std::vector<int>* unique_ids) {
   for (std::vector<CreditCard*>::const_iterator iter =
            personal_data_->credit_cards().begin();
        iter != personal_data_->credit_cards().end(); ++iter) {
     CreditCard* credit_card = *iter;
 
     // The value of the stored data for this field type in the |credit_card|.
     string16 creditcard_field_value = credit_card->GetFieldText(type);
     if (!creditcard_field_value.empty() &&
-        StartsWith(creditcard_field_value, field.value(), false)) {
+        StartsWith(creditcard_field_value, field.value, false)) {
       if (type.field_type() == CREDIT_CARD_NUMBER)
         creditcard_field_value = credit_card->ObfuscatedNumber();
 
       values->push_back(creditcard_field_value);
       labels->push_back(kCreditCardPrefix + credit_card->LastFourDigits());
       icons->push_back(credit_card->type());
       unique_ids->push_back(PackGUIDs(credit_card->guid(), std::string()));
     }
   }
 }
 
 void AutofillManager::FillCreditCardFormField(const CreditCard* credit_card,
                                               AutofillType type,
                                               webkit_glue::FormField* field) {
   DCHECK(credit_card);
   DCHECK_EQ(AutofillType::CREDIT_CARD, type.group());
   DCHECK(field);
 
-  if (field->form_control_type() == ASCIIToUTF16("select-one")) {
+  if (field->form_control_type == ASCIIToUTF16("select-one")) {
     autofill::FillSelectControl(*credit_card, type, field);
-  } else if (field->form_control_type() == ASCIIToUTF16("month")) {
+  } else if (field->form_control_type == ASCIIToUTF16("month")) {
     // HTML5 input="month" consists of year-month.
     string16 year = credit_card->GetFieldText(
         AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR));
     string16 month = credit_card->GetFieldText(
         AutofillType(CREDIT_CARD_EXP_MONTH));
     if (!year.empty() && !month.empty()) {
       // Fill the value only if |credit_card| includes both year and month
       // information.
-      field->set_value(year + ASCIIToUTF16("-") + month);
+      field->value = year + ASCIIToUTF16("-") + month;
     }
   } else {
-    field->set_value(credit_card->GetFieldText(type));
+    field->value = credit_card->GetFieldText(type);
   }
 }
 
 void AutofillManager::FillFormField(const AutoFillProfile* profile,
                                     AutofillType type,
                                     webkit_glue::FormField* field) {
   DCHECK(profile);
   DCHECK_NE(AutofillType::CREDIT_CARD, type.group());
   DCHECK(field);
 
   if (type.subgroup() == AutofillType::PHONE_NUMBER) {
     FillPhoneNumberField(profile, type, field);
   } else {
-    if (field->form_control_type() == ASCIIToUTF16("select-one"))
+    if (field->form_control_type == ASCIIToUTF16("select-one"))
       autofill::FillSelectControl(*profile, type, field);
     else
-      field->set_value(profile->GetFieldText(type));
+      field->value = profile->GetFieldText(type);
   }
 }
 
 void AutofillManager::FillPhoneNumberField(const AutoFillProfile* profile,
                                            AutofillType type,
                                            webkit_glue::FormField* field) {
   // If we are filling a phone number, check to see if the size field
   // matches the "prefix" or "suffix" sizes and fill accordingly.
   string16 number = profile->GetFieldText(AutofillType(type));
   bool has_valid_suffix_and_prefix = (number.length() ==
       static_cast<size_t>(PhoneNumber::kPrefixLength +
                           PhoneNumber::kSuffixLength));
   if (has_valid_suffix_and_prefix &&
-      field->max_length() == PhoneNumber::kPrefixLength) {
+      field->max_length == PhoneNumber::kPrefixLength) {
     number = number.substr(PhoneNumber::kPrefixOffset,
                            PhoneNumber::kPrefixLength);
-    field->set_value(number);
+    field->value = number;
   } else if (has_valid_suffix_and_prefix &&
-             field->max_length() == PhoneNumber::kSuffixLength) {
+             field->max_length == PhoneNumber::kSuffixLength) {
     number = number.substr(PhoneNumber::kSuffixOffset,
                            PhoneNumber::kSuffixLength);
-    field->set_value(number);
+    field->value = number;
   } else {
-    field->set_value(number);
+    field->value = number;
   }
 }
 
 void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
   std::vector<FormStructure*> non_queryable_forms;
   for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
     if (!form_structure->ShouldBeParsed(false))
       continue;
@@ skipping 66 matching lines @@
     return std::string();
 
   std::map<int, std::string>::const_iterator iter = id_guid_map_.find(id);
   if (iter == id_guid_map_.end()) {
     NOTREACHED();
     return std::string();
   }
 
   return iter->second;
 }