Remove ScopedVector from autofill::FormStructure

components/autofill/core/browser/form_structure.cc

 // Copyright 2013 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 "components/autofill/core/browser/form_structure.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 303 matching lines @@
       has_password_field_ = true;
     else
       all_fields_are_passwords_ = false;
 
     // Generate a unique name for this field by appending a counter to the name.
     // Make sure to prepend the counter with a non-numeric digit so that we are
     // guaranteed to avoid collisions.
     base::string16 unique_name =
         field.name + base::ASCIIToUTF16("_") +
         base::SizeTToString16(++unique_names[field.name]);
-    fields_.push_back(new AutofillField(field, unique_name));
+    fields_.push_back(base::MakeUnique<AutofillField>(field, unique_name));
   }
 
   form_signature_ = autofill::CalculateFormSignature(form);
   // Do further processing on the fields, as needed.
   ProcessExtractedFields();
 }
 
 FormStructure::~FormStructure() {}
 
 void FormStructure::DetermineHeuristicTypes() {
   const auto determine_heuristic_types_start_time = base::TimeTicks::Now();
 
   // First, try to detect field types based on each field's |autocomplete|
   // attribute value.
   if (!was_parsed_for_autocomplete_attributes_)
     ParseFieldTypesFromAutocompleteAttributes();
 
   // Then if there are enough active fields, and if we are dealing with either a
   // proper <form> or a <form>-less checkout, run the heuristics and server
   // prediction routines.
   if (active_field_count() >= kRequiredFieldsForPredictionRoutines &&
       (is_form_tag_ || is_formless_checkout_)) {
     const FieldCandidatesMap field_type_map =
-        FormField::ParseFormFields(fields_.get(), is_form_tag_);
-    for (AutofillField* field : fields_) {
+        FormField::ParseFormFields(fields_, is_form_tag_);
+    for (const auto& field : fields_) {
       const auto iter = field_type_map.find(field->unique_name());
       if (iter != field_type_map.end())
         field->set_heuristic_type(iter->second.BestHeuristicType());
     }
   }
 
   UpdateAutofillCount();
   IdentifySections(has_author_specified_sections_);
 
   if (IsAutofillable()) {
@@ skipping 12 matching lines @@
 bool FormStructure::EncodeUploadRequest(
     const ServerFieldTypeSet& available_field_types,
     bool form_was_autofilled,
     const std::string& login_form_signature,
     bool observed_submission,
     AutofillUploadContents* upload) const {
   DCHECK(ShouldBeCrowdsourced());
 
   // Verify that |available_field_types| agrees with the possible field types we
   // are uploading.
-  for (const AutofillField* field : *this) {
+  for (const auto& field : fields_) {
     for (const auto& type : field->possible_types()) {
       DCHECK(type == UNKNOWN_TYPE || type == EMPTY_TYPE ||
              available_field_types.count(type));
     }
   }
 
   upload->set_submission(observed_submission);
   upload->set_client_version(kClientVersion);
   upload->set_form_signature(form_signature());
   upload->set_autofill_used(form_was_autofilled);
@@ skipping 68 matching lines @@
   bool heuristics_detected_fillable_field = false;
   bool query_response_overrode_heuristics = false;
 
   // Copy the field types into the actual form.
   auto current_field = response.field().begin();
   for (FormStructure* form : forms) {
     form->upload_required_ =
         response.upload_required() ? UPLOAD_REQUIRED : UPLOAD_NOT_REQUIRED;
 
     bool query_response_has_no_server_data = true;
-    for (AutofillField* field : form->fields_) {
+    for (const auto& field : *form) {
       if (form->ShouldSkipField(*field))
         continue;
 
       // In some cases *successful* response does not return all the fields.
       // Quit the update of the types then.
       if (current_field == response.field().end())
         break;
 
       ServerFieldType field_type =
           static_cast<ServerFieldType>(current_field->autofill_type());
@@ skipping 44 matching lines @@
   std::vector<FormDataPredictions> forms;
   forms.reserve(form_structures.size());
   for (const FormStructure* form_structure : form_structures) {
     FormDataPredictions form;
     form.data.name = form_structure->form_name_;
     form.data.origin = form_structure->source_url_;
     form.data.action = form_structure->target_url_;
     form.data.is_form_tag = form_structure->is_form_tag_;
     form.signature = form_structure->FormSignatureAsStr();
 
-    for (const AutofillField* field : form_structure->fields_) {
+    for (const auto& field : *form_structure) {
       form.data.fields.push_back(FormFieldData(*field));
 
       FormFieldDataPredictions annotated_field;
       annotated_field.signature = field->FieldSignatureAsStr();
       annotated_field.heuristic_type =
           AutofillType(field->heuristic_type()).ToString();
       annotated_field.server_type =
           AutofillType(field->server_type()).ToString();
       annotated_field.overall_type = field->Type().ToString();
       annotated_field.parseable_name =
@@ skipping 20 matching lines @@
 bool FormStructure::IsAutofillable() const {
   if (autofill_count() < kRequiredFieldsForPredictionRoutines)
     return false;
 
   return ShouldBeParsed();
 }
 
 bool FormStructure::IsCompleteCreditCardForm() const {
   bool found_cc_number = false;
   bool found_cc_expiration = false;
-  for (const AutofillField* field : fields_) {
+  for (const auto& field : fields_) {
     ServerFieldType type = field->Type().GetStorableType();
     if (!found_cc_expiration && IsCreditCardExpirationType(type)) {
       found_cc_expiration = true;
     } else if (!found_cc_number && type == CREDIT_CARD_NUMBER) {
       found_cc_number = true;
     }
     if (found_cc_expiration && found_cc_number)
       return true;
   }
   return false;
 }
 
 void FormStructure::UpdateAutofillCount() {
   autofill_count_ = 0;
-  for (const AutofillField* field : *this) {
+  for (const auto& field : fields_) {
     if (field && field->IsFieldFillable())
       ++autofill_count_;
   }
 }
 
 bool FormStructure::ShouldBeParsed() const {
   if (active_field_count() < kRequiredFieldsForPredictionRoutines &&
       (!all_fields_are_passwords() ||
        active_field_count() < kRequiredFieldsForFormsWithOnlyPasswordFields) &&
       !has_author_specified_types_) {
     return false;
   }
 
   // Rule out http(s)://*/search?...
   //  e.g. http://www.google.com/search?q=...
   //       http://search.yahoo.com/search?p=...
   if (target_url_.path_piece() == "/search")
     return false;
 
   bool has_text_field = false;
-  for (const AutofillField* it : *this) {
+  for (const auto& it : fields_) {
     has_text_field |= it->form_control_type != "select-one";
   }
 
   return has_text_field;
 }
 
 bool FormStructure::ShouldBeCrowdsourced() const {
   return (has_password_field_ ||
           active_field_count() >= kRequiredFieldsForPredictionRoutines) &&
          ShouldBeParsed();
 }
 
 void FormStructure::UpdateFromCache(const FormStructure& cached_form) {
   // Map from field signatures to cached fields.
   std::map<std::string, const AutofillField*> cached_fields;
   for (size_t i = 0; i < cached_form.field_count(); ++i) {
     const AutofillField* field = cached_form.field(i);
     cached_fields[field->FieldSignatureAsStr()] = field;
   }
 
-  for (AutofillField* field : *this) {
+  for (const auto& field : fields_) {
     std::map<std::string, const AutofillField*>::const_iterator cached_field =
         cached_fields.find(field->FieldSignatureAsStr());
     if (cached_field != cached_fields.end()) {
       if (field->form_control_type != "select-one" &&
           field->value == cached_field->second->value) {
         // From the perspective of learning user data, text fields containing
         // default values are equivalent to empty fields.
         field->value = base::string16();
       }
 
@@ skipping 194 matching lines @@
         } else {
           AutofillMetrics::LogFormFillDurationFromInteractionWithoutAutofill(
               elapsed);
         }
       }
     }
   }
 }
 
 void FormStructure::LogQualityMetricsBasedOnAutocomplete() const {
-  for (const AutofillField* field : fields_) {
+  for (const auto& field : fields_) {
     if (field->html_type() != HTML_TYPE_UNSPECIFIED &&
         field->html_type() != HTML_TYPE_UNRECOGNIZED) {
       // The type inferred by the autocomplete attribute.
       AutofillType type(field->html_type(), field->html_mode());
       ServerFieldType actual_field_type = type.GetStorableType();
 
       const AutofillMetrics::QualityMetricType metric_type =
           AutofillMetrics::TYPE_AUTOCOMPLETE_BASED;
       // Log the quality of our heuristics predictions.
       if (field->heuristic_type() == UNKNOWN_TYPE) {
@@ skipping 20 matching lines @@
       }
     }
   }
 }
 
 void FormStructure::ParseFieldTypesFromAutocompleteAttributes() {
   const std::string kDefaultSection = "-default";
 
   has_author_specified_types_ = false;
   has_author_specified_sections_ = false;
-  for (AutofillField* field : fields_) {
+  for (const auto& field : fields_) {
     // To prevent potential section name collisions, add a default suffix for
     // other fields.  Without this, 'autocomplete' attribute values
     // "section--shipping street-address" and "shipping street-address" would be
     // parsed identically, given the section handling code below.  We do this
     // before any validation so that fields with invalid attributes still end up
     // in the default section.  These default section names will be overridden
     // by subsequent heuristic parsing steps if there are no author-specified
     // section names.
     field->set_section(kDefaultSection);
 
@@ skipping 99 matching lines @@
         break;
       }
     }
   }
   return filled_something;
 }
 
 std::set<base::string16> FormStructure::PossibleValues(ServerFieldType type) {
   std::set<base::string16> values;
   AutofillType target_type(type);
-  for (const AutofillField* field : fields_) {
+  for (const auto& field : fields_) {
     if (field->Type().GetStorableType() != target_type.GetStorableType() ||
         field->Type().group() != target_type.group()) {
       continue;
     }
 
     // No option values; anything goes.
     if (field->option_values.empty()) {
       values.clear();
       break;
     }
 
     for (const base::string16& val : field->option_values) {
       if (!val.empty())
         values.insert(base::i18n::ToUpper(val));
     }
 
     for (const base::string16& content : field->option_contents) {
       if (!content.empty())
         values.insert(base::i18n::ToUpper(content));
     }
   }
 
   return values;
 }
 
 base::string16 FormStructure::GetUniqueValue(HtmlFieldType type) const {
   base::string16 value;
-  for (const AutofillField* field : fields_) {
+  for (const auto& field : fields_) {
     if (field->html_type() != type)
       continue;
 
     // More than one value found; abort rather than choosing one arbitrarily.
     if (!value.empty() && !field->value.empty()) {
       value.clear();
       break;
     }
 
     value = field->value;
   }
 
   return value;
 }
 
 const AutofillField* FormStructure::field(size_t index) const {
   if (index >= fields_.size()) {
     NOTREACHED();
     return NULL;
   }
 
-  return fields_[index];
+  return fields_[index].get();
 }
 
 AutofillField* FormStructure::field(size_t index) {
   return const_cast<AutofillField*>(
       static_cast<const FormStructure*>(this)->field(index));
 }
 
 size_t FormStructure::field_count() const {
   return fields_.size();
 }
 
 size_t FormStructure::active_field_count() const {
   return active_field_count_;
 }
 
 FormData FormStructure::ToFormData() const {
   FormData data;
   data.name = form_name_;
   data.origin = source_url_;
   data.action = target_url_;
 
-  for (size_t i = 0; i < fields_.size(); ++i) {
-    data.fields.push_back(FormFieldData(*fields_[i]));
-  }
+  data.fields.resize(fields_.size());
+  std::transform(fields_.cbegin(), fields_.cend(), data.fields.begin(),
+                 [](const std::unique_ptr<AutofillField>& field) {
+                   return FormFieldData(*field);
+                 });
 
   return data;
 }
 
 bool FormStructure::operator==(const FormData& form) const {
   // TODO(jhawkins): Is this enough to differentiate a form?
   if (form_name_ == form.name && source_url_ == form.origin &&
       target_url_ == form.action) {
     return true;
   }
 
   // TODO(jhawkins): Compare field names, IDs and labels once we have labels
   // set up.
 
   return false;
 }
 
 bool FormStructure::operator!=(const FormData& form) const {
   return !operator==(form);
 }
 
 void FormStructure::EncodeFormForQuery(
     AutofillQueryContents::Form* query_form) const {
   DCHECK(!IsMalformed());
 
   query_form->set_signature(form_signature());
-  for (const AutofillField* field : fields_) {
+  for (const auto& field : fields_) {
     if (ShouldSkipField(*field))
       continue;
 
     AutofillQueryContents::Form::Field* added_field = query_form->add_field();
 
     added_field->set_signature(field->GetFieldSignature());
 
     if (IsAutofillFieldMetadataEnabled()) {
       added_field->set_type(field->form_control_type);
 
       if (!field->name.empty())
         added_field->set_name(base::UTF16ToUTF8(field->name));
 
     }
   }
 }
 
 void FormStructure::EncodeFormForUpload(AutofillUploadContents* upload) const {
   DCHECK(!IsMalformed());
 
-  for (const AutofillField* field : fields_) {
+  for (const auto& field : fields_) {
     // Don't upload checkable fields.
     if (IsCheckable(field->check_status))
       continue;
 
     const ServerFieldTypeSet& types = field->possible_types();
     for (const auto& field_type : types) {
       // Add the same field elements as the query and a few more below.
       if (ShouldSkipField(*field))
         continue;
 
@@ skipping 47 matching lines @@
     return;
 
   if (!has_author_specified_sections) {
     // Name sections after the first field in the section.
     base::string16 current_section = fields_.front()->unique_name();
 
     // Keep track of the types we've seen in this section.
     std::set<ServerFieldType> seen_types;
     ServerFieldType previous_type = UNKNOWN_TYPE;
 
-    for (AutofillField* field : fields_) {
+    for (const auto& field : fields_) {
       const ServerFieldType current_type = field->Type().GetStorableType();
 
       bool already_saw_current_type = seen_types.count(current_type) > 0;
 
       // Forms often ask for multiple phone numbers -- e.g. both a daytime and
       // evening phone number.  Our phone number detection is also generally a
       // little off.  Hence, ignore this field type as a signal here.
       if (AutofillType(current_type).group() == PHONE_HOME)
         already_saw_current_type = false;
 
@@ skipping 33 matching lines @@
         seen_types.insert(current_type);
         previous_type = current_type;
       }
 
       field->set_section(base::UTF16ToUTF8(current_section));
     }
   }
 
   // Ensure that credit card and address fields are in separate sections.
   // This simplifies the section-aware logic in autofill_manager.cc.
-  for (AutofillField* field : fields_) {
+  for (const auto& field : fields_) {
     FieldTypeGroup field_type_group = field->Type().group();
     if (field_type_group == CREDIT_CARD)
       field->set_section(field->section() + "-cc");
     else
       field->set_section(field->section() + "-default");
   }
 }
 
 bool FormStructure::ShouldSkipField(const FormFieldData& field) const {
   return IsCheckable(field.check_status);
 }
 
 void FormStructure::ProcessExtractedFields() {
   // Update the field name parsed by heuristics if several criteria are met.
   // Several fields must be present in the form.
   if (field_count() < kCommonNamePrefixRemovalFieldThreshold)
     return;
 
   // Find the longest common prefix within all the field names.
   std::vector<base::string16> names;
   names.reserve(field_count());
-  for (const AutofillField* field : *this)
+  for (const auto& field : fields_)
     names.push_back(field->name);
 
   const base::string16 longest_prefix = FindLongestCommonPrefix(names);
   if (longest_prefix.size() < kMinCommonNamePrefixLength)
     return;
 
   // The name without the prefix will be used for heuristics parsing.
-  for (AutofillField* field : *this) {
+  for (const auto& field : fields_) {
     if (field->name.size() > longest_prefix.size()) {
       field->set_parseable_name(
           field->name.substr(longest_prefix.size(), field->name.size()));
     }
   }
 }
 
 // static
 base::string16 FormStructure::FindLongestCommonPrefix(
     const std::vector<base::string16>& strings) {
@@ skipping 21 matching lines @@
               filtered_strings[0].at(prefix_len)) {
         // Mismatch found.
         return filtered_strings[i].substr(0, prefix_len);
       }
     }
   }
   return filtered_strings[0];
 }
 
 }  // namespace autofill