Convert string16 -> base::string16 in components/

components/autofill/browser/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 "components/autofill/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 62 matching lines @@
 const double kAutofillPositiveUploadRateDefaultValue = 0.20;
 const double kAutofillNegativeUploadRateDefaultValue = 0.20;
 
 const size_t kMaxRecentFormSignaturesToRemember = 3;
 
 // Set a conservative upper bound on the number of forms we are willing to
 // cache, simply to prevent unbounded memory consumption.
 const size_t kMaxFormCacheSize = 100;
 
 // Removes duplicate suggestions whilst preserving their original order.
-void RemoveDuplicateSuggestions(std::vector<string16>* values,
-                                std::vector<string16>* labels,
-                                std::vector<string16>* icons,
+void RemoveDuplicateSuggestions(std::vector<base::string16>* values,
+                                std::vector<base::string16>* labels,
+                                std::vector<base::string16>* icons,
                                 std::vector<int>* unique_ids) {
   DCHECK_EQ(values->size(), labels->size());
   DCHECK_EQ(values->size(), icons->size());
   DCHECK_EQ(values->size(), unique_ids->size());
 
-  std::set<std::pair<string16, string16> > seen_suggestions;
-  std::vector<string16> values_copy;
-  std::vector<string16> labels_copy;
-  std::vector<string16> icons_copy;
+  std::set<std::pair<base::string16, base::string16> > seen_suggestions;
+  std::vector<base::string16> values_copy;
+  std::vector<base::string16> labels_copy;
+  std::vector<base::string16> icons_copy;
   std::vector<int> unique_ids_copy;
 
   for (size_t i = 0; i < values->size(); ++i) {
-    const std::pair<string16, string16> suggestion((*values)[i], (*labels)[i]);
+    const std::pair<base::string16, base::string16> suggestion(
+        (*values)[i], (*labels)[i]);
     if (seen_suggestions.insert(suggestion).second) {
       values_copy.push_back((*values)[i]);
       labels_copy.push_back((*labels)[i]);
       icons_copy.push_back((*icons)[i]);
       unique_ids_copy.push_back((*unique_ids)[i]);
     }
   }
 
   values->swap(values_copy);
   labels->swap(labels_copy);
@@ skipping 31 matching lines @@
     const std::vector<AutofillProfile>& profiles,
     const std::vector<CreditCard>& credit_cards,
     const std::string& app_locale,
     FormStructure* submitted_form) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   // For each field in the |submitted_form|, extract the value.  Then for each
   // profile or credit card, identify any stored types that match the value.
   for (size_t i = 0; i < submitted_form->field_count(); ++i) {
     AutofillField* field = submitted_form->field(i);
-    string16 value = CollapseWhitespace(field->value, false);
+    base::string16 value = CollapseWhitespace(field->value, false);
 
     FieldTypeSet matching_types;
     for (std::vector<AutofillProfile>::const_iterator it = profiles.begin();
          it != profiles.end(); ++it) {
       it->GetMatchingTypes(value, app_locale, &matching_types);
     }
     for (std::vector<CreditCard>::const_iterator it = credit_cards.begin();
           it != credit_cards.end(); ++it) {
       it->GetMatchingTypes(value, app_locale, &matching_types);
     }
@@ skipping 349 matching lines @@
 }
 
 void AutofillManager::OnQueryFormFieldAutofill(int query_id,
                                                const FormData& form,
                                                const FormFieldData& field,
                                                const gfx::RectF& bounding_box,
                                                bool display_warning) {
   if (autocheckout_manager_.is_autocheckout_bubble_showing())
     return;
 
-  std::vector<string16> values;
-  std::vector<string16> labels;
-  std::vector<string16> icons;
+  std::vector<base::string16> values;
+  std::vector<base::string16> labels;
+  std::vector<base::string16> icons;
   std::vector<int> unique_ids;
 
   if (external_delegate_) {
     external_delegate_->OnQuery(query_id,
                                 form,
                                 field,
                                 bounding_box,
                                 display_warning);
   }
 
@@ skipping 23 matching lines @@
       // Don't provide Autofill suggestions when Autofill is disabled, and don't
       // provide credit card suggestions for non-HTTPS pages. However, provide a
       // warning to the user in these cases.
       int warning = 0;
       if (!form_structure->IsAutofillable(true))
         warning = IDS_AUTOFILL_WARNING_FORM_DISABLED;
       else if (is_filling_credit_card && !FormIsHTTPS(*form_structure))
         warning = IDS_AUTOFILL_WARNING_INSECURE_CONNECTION;
       if (warning) {
         values.assign(1, l10n_util::GetStringUTF16(warning));
-        labels.assign(1, string16());
-        icons.assign(1, string16());
+        labels.assign(1, base::string16());
+        icons.assign(1, base::string16());
         unique_ids.assign(1,
                           WebKit::WebAutofillClient::MenuItemIDWarningMessage);
       } else {
         bool section_is_autofilled =
             SectionIsAutofilled(*form_structure, form,
                                 autofill_field->section());
         if (section_is_autofilled) {
           // If the relevant section is auto-filled and the renderer is querying
           // for suggestions, then the user is editing the value of a field.
           // In this case, mimic autocomplete: don't display labels or icons,
           // as that information is redundant.
-          labels.assign(labels.size(), string16());
-          icons.assign(icons.size(), string16());
+          labels.assign(labels.size(), base::string16());
+          icons.assign(icons.size(), base::string16());
         }
 
         // When filling credit card suggestions, the values and labels are
         // typically obfuscated, which makes detecting duplicates hard.  Since
         // duplicates only tend to be a problem when filling address forms
         // anyway, only don't de-dup credit card suggestions.
         if (!is_filling_credit_card)
           RemoveDuplicateSuggestions(&values, &labels, &icons, &unique_ids);
 
         // The first time we show suggestions on this page, log the number of
@@ skipping 163 matching lines @@
 
   // TODO(csharp): If we are dealing with a variant only the variant should
   // be deleted, instead of doing nothing.
   // http://crbug.com/124211
   if (variant != 0)
     return;
 
   personal_data_->RemoveByGUID(form_group->GetGUID());
 }
 
-void AutofillManager::RemoveAutocompleteEntry(const string16& name,
-                                              const string16& value) {
+void AutofillManager::RemoveAutocompleteEntry(const base::string16& name,
+                                              const base::string16& value) {
   autocomplete_history_manager_.OnRemoveAutocompleteEntry(name, value);
 }
 
 content::WebContents* AutofillManager::GetWebContents() const {
   return web_contents();
 }
 
 const std::vector<FormStructure*>& AutofillManager::GetFormStructures() {
   return form_structures_.get();
 }
@@ skipping 16 matching lines @@
 void AutofillManager::OnAddPasswordFormMapping(
       const FormFieldData& form,
       const PasswordFormFillData& fill_data) {
   if (external_delegate_)
     external_delegate_->AddPasswordFormMapping(form, fill_data);
 }
 
 void AutofillManager::OnShowPasswordSuggestions(
     const FormFieldData& field,
     const gfx::RectF& bounds,
-    const std::vector<string16>& suggestions) {
+    const std::vector<base::string16>& suggestions) {
   if (external_delegate_)
     external_delegate_->OnShowPasswordSuggestions(suggestions, field, bounds);
 }
 
-void AutofillManager::OnSetDataList(const std::vector<string16>& values,
-                                    const std::vector<string16>& labels,
-                                    const std::vector<string16>& icons,
+void AutofillManager::OnSetDataList(const std::vector<base::string16>& values,
+                                    const std::vector<base::string16>& labels,
+                                    const std::vector<base::string16>& icons,
                                     const std::vector<int>& unique_ids) {
   if (labels.size() != values.size() ||
       icons.size() != values.size() ||
       unique_ids.size() != values.size()) {
     return;
   }
   if (external_delegate_) {
     external_delegate_->SetCurrentDataListValues(values,
                                                  labels,
                                                  icons,
@@ skipping 346 matching lines @@
     return false;
 
   // Add the new or updated form to our cache.
   form_structures_.push_back(
       new FormStructure(live_form, GetAutocheckoutURLPrefix()));
   *updated_form = *form_structures_.rbegin();
   (*updated_form)->DetermineHeuristicTypes(*metric_logger_);
 
   // If we have cached data, propagate it to the updated form.
   if (cached_form) {
-    std::map<string16, const AutofillField*> cached_fields;
+    std::map<base::string16, 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->unique_name()] = field;
     }
 
     for (size_t i = 0; i < (*updated_form)->field_count(); ++i) {
       AutofillField* field = (*updated_form)->field(i);
-      std::map<string16, const AutofillField*>::iterator cached_field =
+      std::map<base::string16, const AutofillField*>::iterator cached_field =
           cached_fields.find(field->unique_name());
       if (cached_field != cached_fields.end()) {
         field->set_server_type(cached_field->second->server_type());
         field->is_autofilled = cached_field->second->is_autofilled;
       }
     }
 
     // Note: We _must not_ remove the original version of the cached form from
     // the list of |form_structures_|.  Otherwise, we break parsing of the
     // crowdsourcing server's response to our query.
   }
 
   // Annotate the updated form with its predicted types.
   std::vector<FormStructure*> forms(1, *updated_form);
   SendAutofillTypePredictions(forms);
 
   return true;
 }
 
 void AutofillManager::GetProfileSuggestions(
     FormStructure* form,
     const FormFieldData& field,
     AutofillFieldType type,
-    std::vector<string16>* values,
-    std::vector<string16>* labels,
-    std::vector<string16>* icons,
+    std::vector<base::string16>* values,
+    std::vector<base::string16>* labels,
+    std::vector<base::string16>* icons,
     std::vector<int>* unique_ids) const {
   std::vector<AutofillFieldType> field_types(form->field_count());
   for (size_t i = 0; i < form->field_count(); ++i) {
     field_types[i] = form->field(i)->type();
   }
   std::vector<GUIDPair> guid_pairs;
 
   personal_data_->GetProfileSuggestions(
       type, field.value, field.is_autofilled, field_types,
       values, labels, icons, &guid_pairs);
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(GUIDPair(std::string(), 0),
                                     guid_pairs[i]));
   }
 }
 
 void AutofillManager::GetCreditCardSuggestions(
     const FormFieldData& field,
     AutofillFieldType type,
-    std::vector<string16>* values,
-    std::vector<string16>* labels,
-    std::vector<string16>* icons,
+    std::vector<base::string16>* values,
+    std::vector<base::string16>* labels,
+    std::vector<base::string16>* icons,
     std::vector<int>* unique_ids) const {
   std::vector<GUIDPair> guid_pairs;
   personal_data_->GetCreditCardSuggestions(
       type, field.value, values, labels, icons, &guid_pairs);
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(guid_pairs[i], GUIDPair(std::string(), 0)));
   }
 }
 
@@ skipping 94 matching lines @@
   *profile_guid = IDToGUID(profile_id);
 }
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }