Convert string16 -> base::string16 in components/

components/autofill/browser/autofill_manager_unittest.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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 46 matching lines @@
 using testing::_;
 using WebKit::WebFormElement;
 
 namespace {
 
 // The page ID sent to the AutofillManager from the RenderView, used to send
 // an IPC message back to the renderer.
 const int kDefaultPageID = 137;
 
 typedef Tuple5<int,
-               std::vector<string16>,
-               std::vector<string16>,
-               std::vector<string16>,
+               std::vector<base::string16>,
+               std::vector<base::string16>,
+               std::vector<base::string16>,
                std::vector<int> > AutofillParam;
 
 class TestPersonalDataManager : public PersonalDataManager {
  public:
   TestPersonalDataManager() : PersonalDataManager("en-US") {
     CreateTestAutofillProfiles(&web_profiles_);
     CreateTestCreditCards(&credit_cards_);
   }
 
   void SetBrowserContext(content::BrowserContext* context) {
@@ skipping 242 matching lines @@
     autofill_test::CreateTestFormField(
         "Expiration Date", "ccmonth", "", "text", &field);
     form->fields.push_back(field);
     autofill_test::CreateTestFormField(
         "", "ccyear", "", "text", &field);
     form->fields.push_back(field);
   }
 }
 
 void ExpectSuggestions(int page_id,
-                       const std::vector<string16>& values,
-                       const std::vector<string16>& labels,
-                       const std::vector<string16>& icons,
+                       const std::vector<base::string16>& values,
+                       const std::vector<base::string16>& labels,
+                       const std::vector<base::string16>& icons,
                        const std::vector<int>& unique_ids,
                        int expected_page_id,
                        size_t expected_num_suggestions,
-                       const string16 expected_values[],
-                       const string16 expected_labels[],
-                       const string16 expected_icons[],
+                       const base::string16 expected_values[],
+                       const base::string16 expected_labels[],
+                       const base::string16 expected_icons[],
                        const int expected_unique_ids[]) {
   EXPECT_EQ(expected_page_id, page_id);
   ASSERT_EQ(expected_num_suggestions, values.size());
   ASSERT_EQ(expected_num_suggestions, labels.size());
   ASSERT_EQ(expected_num_suggestions, icons.size());
   ASSERT_EQ(expected_num_suggestions, unique_ids.size());
   for (size_t i = 0; i < expected_num_suggestions; ++i) {
     SCOPED_TRACE(base::StringPrintf("i: %" PRIuS, i));
     EXPECT_EQ(expected_values[i], values[i]);
     EXPECT_EQ(expected_labels[i], labels[i]);
@@ skipping 377 matching lines @@
                                                 field,
                                                 gfx::Rect(),
                                                 false);
   }
 
   void GetAutofillSuggestions(const FormData& form,
                               const FormFieldData& field) {
     GetAutofillSuggestions(kDefaultPageID, form, field);
   }
 
-  void AutocompleteSuggestionsReturned(const std::vector<string16>& result) {
+  void AutocompleteSuggestionsReturned(
+      const std::vector<base::string16>& result) {
     autofill_manager_->autocomplete_history_manager_.SendSuggestions(&result);
   }
 
   void FormsSeen(const std::vector<FormData>& forms) {
     autofill_manager_->OnFormsSeen(forms, base::TimeTicks(), false);
   }
 
   void PartialFormsSeen(const std::vector<FormData>& forms) {
     autofill_manager_->OnFormsSeen(forms, base::TimeTicks(), true);
   }
 
   void FormSubmitted(const FormData& form) {
     if (autofill_manager_->OnFormSubmitted(form, base::TimeTicks::Now()))
       autofill_manager_->WaitForAsyncFormSubmit();
   }
 
   void FillAutofillFormData(int query_id,
                             const FormData& form,
                             const FormFieldData& field,
                             int unique_id) {
     autofill_manager_->OnFillAutofillFormData(query_id, form, field, unique_id);
   }
 
   int PackGUIDs(const GUIDPair& cc_guid, const GUIDPair& profile_guid) const {
     return autofill_manager_->PackGUIDs(cc_guid, profile_guid);
   }
 
   bool GetAutofillSuggestionsMessage(int* page_id,
-                                     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 uint32 kMsgID = AutofillMsg_SuggestionsReturned::ID;
     const IPC::Message* message =
         process()->sink().GetFirstMessageMatching(kMsgID);
     if (!message)
       return false;
 
     AutofillParam autofill_param;
     AutofillMsg_SuggestionsReturned::Read(message, &autofill_param);
     if (page_id)
@@ skipping 111 matching lines @@
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   GetAutofillSuggestionsMessage(
       &page_id, &values, &labels, &icons, &unique_ids);
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("Elvis"),
     ASCIIToUTF16("Charles")
   };
   // Inferred labels include full first relevant field, which in this case is
   // the address line 1.
-  string16 expected_labels[] = {
+  base::string16 expected_labels[] = {
     ASCIIToUTF16("3734 Elvis Presley Blvd."),
     ASCIIToUTF16("123 Apple St.")
   };
-  string16 expected_icons[] = {string16(), string16()};
+  base::string16 expected_icons[] = {base::string16(), base::string16()};
   int expected_unique_ids[] = {1, 2};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that in the case of Autocheckout, forms seen are in order supplied.
 TEST_F(AutofillManagerTest, AutocheckoutFormsSeen) {
   FormData shipping_options;
   CreateTestShippingOptionsFormData(&shipping_options);
@@ skipping 39 matching lines @@
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field;
   autofill_test::CreateTestFormField("First Name", "firstname", "E", "text",
                                      &field);
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {ASCIIToUTF16("Elvis")};
-  string16 expected_labels[] = {ASCIIToUTF16("3734 Elvis Presley Blvd.")};
-  string16 expected_icons[] = {string16()};
+  base::string16 expected_values[] = {ASCIIToUTF16("Elvis")};
+  base::string16 expected_labels[] = {ASCIIToUTF16("3734 Elvis Presley Blvd.")};
+  base::string16 expected_icons[] = {base::string16()};
   int expected_unique_ids[] = {1};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return no suggestions when the form has no relevant fields.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsUnknownFields) {
   // Set up our form data.
   FormData form;
@@ skipping 35 matching lines @@
       new AutofillProfile(
           *(autofill_manager_->GetProfileWithGUID(
               "00000000-0000-0000-0000-000000000001")));
   autofill_manager_->AddProfile(duplicate_profile);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("Elvis"),
     ASCIIToUTF16("Charles")
   };
-  string16 expected_labels[] = {
+  base::string16 expected_labels[] = {
     ASCIIToUTF16("3734 Elvis Presley Blvd."),
     ASCIIToUTF16("123 Apple St.")
   };
-  string16 expected_icons[] = {string16(), string16()};
+  base::string16 expected_icons[] = {base::string16(), base::string16()};
   int expected_unique_ids[] = {1, 2};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return no suggestions when autofill is disabled.
 TEST_F(AutofillManagerTest, GetProfileSuggestionsAutofillDisabledByUser) {
   // Set up our form data.
   FormData form;
@@ skipping 17 matching lines @@
   CreateTestAddressFormData(&form);
   form.method = ASCIIToUTF16("GET");
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_FORM_DISABLED)
   };
-  string16 expected_labels[] = {string16()};
-  string16 expected_icons[] = {string16()};
+  base::string16 expected_labels[] = {base::string16()};
+  base::string16 expected_icons[] = {base::string16()};
   int expected_unique_ids[] =
       {WebKit::WebAutofillClient::MenuItemIDWarningMessage};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 
   // Now add some Autocomplete suggestions. We should return the autocomplete
   // suggestions and the warning; these will be culled by the renderer.
   const int kPageID2 = 2;
   GetAutofillSuggestions(kPageID2, form, field);
 
-  std::vector<string16> suggestions;
+  std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("Jay"));
   suggestions.push_back(ASCIIToUTF16("Jason"));
   AutocompleteSuggestionsReturned(suggestions);
 
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values2[] = {
+  base::string16 expected_values2[] = {
     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_FORM_DISABLED),
     ASCIIToUTF16("Jay"),
     ASCIIToUTF16("Jason")
   };
-  string16 expected_labels2[] = {string16(), string16(), string16()};
-  string16 expected_icons2[] = {string16(), string16(), string16()};
+  base::string16 expected_labels2[] = { base::string16(), base::string16(),
+                                        base::string16()};
+  base::string16 expected_icons2[] = { base::string16(), base::string16(),
+                                       base::string16()};
   int expected_unique_ids2[] = {-1, 0, 0};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kPageID2, arraysize(expected_values2), expected_values2,
                     expected_labels2, expected_icons2, expected_unique_ids2);
 
   // Now clear the test profiles and try again -- we shouldn't return a warning.
   personal_data_.ClearAutofillProfiles();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
 
 // Test that we return all credit card profile suggestions when all form fields
 // are empty.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsEmptyValue) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("************3456"),
     ASCIIToUTF16("************8765")
   };
-  string16 expected_labels[] = {ASCIIToUTF16("*3456"), ASCIIToUTF16("*8765")};
-  string16 expected_icons[] = {
+  base::string16 expected_labels[] = { ASCIIToUTF16("*3456"),
+                                       ASCIIToUTF16("*8765")};
+  base::string16 expected_icons[] = {
     ASCIIToUTF16("visaCC"),
     ASCIIToUTF16("genericCC")
   };
   int expected_unique_ids[] = {
     autofill_manager_->GetPackedCreditCardID(4),
     autofill_manager_->GetPackedCreditCardID(5)
   };
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return only matching credit card profile suggestions when the
 // selected form field has been partially filled out.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsMatchCharacter) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field;
   autofill_test::CreateTestFormField(
       "Card Number", "cardnumber", "4", "text", &field);
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {ASCIIToUTF16("************3456")};
-  string16 expected_labels[] = {ASCIIToUTF16("*3456")};
-  string16 expected_icons[] = {ASCIIToUTF16("visaCC")};
+  base::string16 expected_values[] = {ASCIIToUTF16("************3456")};
+  base::string16 expected_labels[] = {ASCIIToUTF16("*3456")};
+  base::string16 expected_icons[] = {ASCIIToUTF16("visaCC")};
   int expected_unique_ids[] = {autofill_manager_->GetPackedCreditCardID(4)};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return credit card profile suggestions when the selected form
 // field is not the credit card number field.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsNonCCNumber) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("Elvis Presley"),
     ASCIIToUTF16("Buddy Holly")
   };
-  string16 expected_labels[] = {ASCIIToUTF16("*3456"), ASCIIToUTF16("*8765")};
-  string16 expected_icons[] = {
+  base::string16 expected_labels[] = { ASCIIToUTF16("*3456"),
+                                       ASCIIToUTF16("*8765") };
+  base::string16 expected_icons[] = {
     ASCIIToUTF16("visaCC"),
     ASCIIToUTF16("genericCC")
   };
   int expected_unique_ids[] = {
     autofill_manager_->GetPackedCreditCardID(4),
     autofill_manager_->GetPackedCreditCardID(5)
   };
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return a warning explaining that credit card profile suggestions
 // are unavailable when the form is not https.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsNonHTTPS) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, false, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION)
   };
-  string16 expected_labels[] = {string16()};
-  string16 expected_icons[] = {string16()};
+  base::string16 expected_labels[] = {base::string16()};
+  base::string16 expected_icons[] = {base::string16()};
   int expected_unique_ids[] = {-1};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 
   // Now add some Autocomplete suggestions. We should show the autocomplete
   // suggestions and the warning.
   const int kPageID2 = 2;
   GetAutofillSuggestions(kPageID2, form, field);
 
-  std::vector<string16> suggestions;
+  std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("Jay"));
   suggestions.push_back(ASCIIToUTF16("Jason"));
   AutocompleteSuggestionsReturned(suggestions);
 
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
-  string16 expected_values2[] = {
+  base::string16 expected_values2[] = {
     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
     ASCIIToUTF16("Jay"),
     ASCIIToUTF16("Jason")
   };
-  string16 expected_labels2[] = {string16(), string16(), string16()};
-  string16 expected_icons2[] = {string16(), string16(), string16()};
+  base::string16 expected_labels2[] = { base::string16(), base::string16(),
+                                        base::string16() };
+  base::string16 expected_icons2[] = { base::string16(), base::string16(),
+                                       base::string16() };
   int expected_unique_ids2[] = {-1, 0, 0};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kPageID2, arraysize(expected_values2), expected_values2,
                     expected_labels2, expected_icons2, expected_unique_ids2);
 
   // Clear the test credit cards and try again -- we shouldn't return a warning.
   personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
@@ skipping 14 matching lines @@
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("************3456"),
     ASCIIToUTF16("************8765"),
     ASCIIToUTF16("************3456")
   };
-  string16 expected_labels[] = {
+  base::string16 expected_labels[] = {
     ASCIIToUTF16("*3456"),
     ASCIIToUTF16("*8765"),
     ASCIIToUTF16("*3456"),
   };
-  string16 expected_icons[] = {
+  base::string16 expected_icons[] = {
     ASCIIToUTF16("visaCC"),
     ASCIIToUTF16("genericCC"),
     ASCIIToUTF16("masterCardCC")
   };
   int expected_unique_ids[] = {
     autofill_manager_->GetPackedCreditCardID(4),
     autofill_manager_->GetPackedCreditCardID(5),
     autofill_manager_->GetPackedCreditCardID(7)
   };
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return profile and credit card suggestions for combined forms.
 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestions) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right address suggestions to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("Elvis"),
     ASCIIToUTF16("Charles")
   };
-  string16 expected_labels[] = {
+  base::string16 expected_labels[] = {
     ASCIIToUTF16("3734 Elvis Presley Blvd."),
     ASCIIToUTF16("123 Apple St.")
   };
-  string16 expected_icons[] = {string16(), string16()};
+  base::string16 expected_icons[] = {base::string16(), base::string16()};
   int expected_unique_ids[] = {1, 2};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 
   const int kPageID2 = 2;
   autofill_test::CreateTestFormField(
       "Card Number", "cardnumber", "", "text", &field);
   GetAutofillSuggestions(kPageID2, form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the credit card suggestions to the renderer.
   page_id = 0;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values2[] = {
+  base::string16 expected_values2[] = {
     ASCIIToUTF16("************3456"),
     ASCIIToUTF16("************8765")
   };
-  string16 expected_labels2[] = {ASCIIToUTF16("*3456"), ASCIIToUTF16("*8765")};
-  string16 expected_icons2[] = {
+  base::string16 expected_labels2[] = { ASCIIToUTF16("*3456"),
+                                        ASCIIToUTF16("*8765")};
+  base::string16 expected_icons2[] = {
     ASCIIToUTF16("visaCC"),
     ASCIIToUTF16("genericCC")
   };
   int expected_unique_ids2[] = {
     autofill_manager_->GetPackedCreditCardID(4),
     autofill_manager_->GetPackedCreditCardID(5)
   };
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kPageID2, arraysize(expected_values2), expected_values2,
                     expected_labels2, expected_icons2, expected_unique_ids2);
 }
 
 // Test that for non-https forms with both address and credit card fields, we
 // only return address suggestions. Instead of credit card suggestions, we
 // should return a warning explaining that credit card profile suggestions are
 // unavailable when the form is not https.
 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestionsNonHttps) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, false, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right address suggestions to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("Elvis"),
     ASCIIToUTF16("Charles")
   };
-  string16 expected_labels[] = {
+  base::string16 expected_labels[] = {
     ASCIIToUTF16("3734 Elvis Presley Blvd."),
     ASCIIToUTF16("123 Apple St.")
   };
-  string16 expected_icons[] = {string16(), string16()};
+  base::string16 expected_icons[] = {base::string16(), base::string16()};
   int expected_unique_ids[] = {1, 2};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 
   autofill_test::CreateTestFormField(
       "Card Number", "cardnumber", "", "text", &field);
   const int kPageID2 = 2;
   GetAutofillSuggestions(kPageID2, form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values2[] = {
+  base::string16 expected_values2[] = {
     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION)
   };
-  string16 expected_labels2[] = {string16()};
-  string16 expected_icons2[] = {string16()};
+  base::string16 expected_labels2[] = {base::string16()};
+  base::string16 expected_icons2[] = {base::string16()};
   int expected_unique_ids2[] = {-1};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kPageID2, arraysize(expected_values2), expected_values2,
                     expected_labels2, expected_icons2, expected_unique_ids2);
 
   // Clear the test credit cards and try again -- we shouldn't return a warning.
   personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
 
 // Test that we correctly combine autofill and autocomplete suggestions.
 TEST_F(AutofillManagerTest, GetCombinedAutofillAndAutocompleteSuggestions) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Add some Autocomplete suggestions.
   // This triggers the combined message send.
-  std::vector<string16> suggestions;
+  std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("Jay"));
   // This suggestion is a duplicate, and should be trimmed.
   suggestions.push_back(ASCIIToUTF16("Elvis"));
   suggestions.push_back(ASCIIToUTF16("Jason"));
   AutocompleteSuggestionsReturned(suggestions);
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("Elvis"),
     ASCIIToUTF16("Charles"),
     ASCIIToUTF16("Jay"),
     ASCIIToUTF16("Jason")
   };
-  string16 expected_labels[] = {
+  base::string16 expected_labels[] = {
     ASCIIToUTF16("3734 Elvis Presley Blvd."),
     ASCIIToUTF16("123 Apple St."),
-    string16(),
-    string16()
+    base::string16(),
+    base::string16()
   };
-  string16 expected_icons[] = {string16(), string16(), string16(), string16()};
+  base::string16 expected_icons[] = { base::string16(), base::string16(),
+                                      base::string16(), base::string16()};
   int expected_unique_ids[] = {1, 2, 0, 0};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return autocomplete-like suggestions when trying to autofill
 // already filled forms.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsWhenFormIsAutofilled) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Mark one of the fields as filled.
   form.fields[2].is_autofilled = true;
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("Elvis"),
     ASCIIToUTF16("Charles")
   };
-  string16 expected_labels[] = {string16(), string16()};
-  string16 expected_icons[] = {string16(), string16()};
+  base::string16 expected_labels[] = {base::string16(), base::string16()};
+  base::string16 expected_icons[] = {base::string16(), base::string16()};
   int expected_unique_ids[] = {1, 2};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that nothing breaks when there are autocomplete suggestions but no
 // autofill suggestions.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsForAutocompleteOnly) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   FormFieldData field;
   autofill_test::CreateTestFormField(
       "Some Field", "somefield", "", "text", &field);
   form.fields.push_back(field);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GetAutofillSuggestions(form, field);
 
   // Add some Autocomplete suggestions.
   // This triggers the combined message send.
-  std::vector<string16> suggestions;
+  std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("one"));
   suggestions.push_back(ASCIIToUTF16("two"));
   AutocompleteSuggestionsReturned(suggestions);
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("one"),
     ASCIIToUTF16("two")
   };
-  string16 expected_labels[] = {string16(), string16()};
-  string16 expected_icons[] = {string16(), string16()};
+  base::string16 expected_labels[] = {base::string16(), base::string16()};
+  base::string16 expected_icons[] = {base::string16(), base::string16()};
   int expected_unique_ids[] = {0, 0};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we do not return duplicate values drawn from multiple profiles when
 // filling an already filled field.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsWithDuplicateValues) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
   AutofillProfile* profile = new AutofillProfile;
   autofill_test::SetProfileInfo(profile, "Elvis", "", "", "", "", "", "", "",
                                 "", "", "", "");
   profile->set_guid("00000000-0000-0000-0000-000000000101");
   autofill_manager_->AddProfile(profile);
 
   FormFieldData& field = form.fields[0];
   field.is_autofilled = true;
   field.value = ASCIIToUTF16("Elvis");
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = { ASCIIToUTF16("Elvis") };
-  string16 expected_labels[] = { string16() };
-  string16 expected_icons[] = { string16() };
+  base::string16 expected_values[] = { ASCIIToUTF16("Elvis") };
+  base::string16 expected_labels[] = { base::string16() };
+  base::string16 expected_icons[] = { base::string16() };
   int expected_unique_ids[] = { 1 };
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that a non-default value is suggested for multi-valued profile, on an
 // unfilled form.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsForMultiValuedProfileUnfilled) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
   AutofillProfile* profile = new AutofillProfile;
   autofill_test::SetProfileInfo(profile, "Elvis", "", "Presley", "me@x.com", "",
                                 "", "", "", "", "", "", "");
   profile->set_guid("00000000-0000-0000-0000-000000000101");
-  std::vector<string16> multi_values(2);
+  std::vector<base::string16> multi_values(2);
   multi_values[0] = ASCIIToUTF16("Elvis Presley");
   multi_values[1] = ASCIIToUTF16("Elena Love");
   profile->SetRawMultiInfo(NAME_FULL, multi_values);
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->AddProfile(profile);
 
   {
     // Get the first name field.
     // Start out with "E", hoping for either "Elvis" or "Elena.
     FormFieldData& field = form.fields[0];
     field.value = ASCIIToUTF16("E");
     field.is_autofilled = false;
     GetAutofillSuggestions(form, field);
 
     // Trigger the |Send|.
-    AutocompleteSuggestionsReturned(std::vector<string16>());
+    AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
     // Test that we sent the right message to the renderer.
     int page_id = 0;
-    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;
     EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels,
                                               &icons, &unique_ids));
-    string16 expected_values[] = {
+    base::string16 expected_values[] = {
       ASCIIToUTF16("Elvis"),
       ASCIIToUTF16("Elena")
     };
-    string16 expected_labels[] = {
+    base::string16 expected_labels[] = {
       ASCIIToUTF16("me@x.com"),
       ASCIIToUTF16("me@x.com")
     };
-    string16 expected_icons[] = { string16(), string16() };
+    base::string16 expected_icons[] = { base::string16(), base::string16() };
     int expected_unique_ids[] = { 1, 2 };
     ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                       kDefaultPageID, arraysize(expected_values),
                       expected_values, expected_labels, expected_icons,
                       expected_unique_ids);
   }
 
   {
     // Get the first name field.
     // This time, start out with "Ele", hoping for "Elena".
     FormFieldData& field = form.fields[0];
     field.value = ASCIIToUTF16("Ele");
     field.is_autofilled = false;
     GetAutofillSuggestions(form, field);
 
     // Trigger the |Send|.
-    AutocompleteSuggestionsReturned(std::vector<string16>());
+    AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
     // Test that we sent the right message to the renderer.
     int page_id = 0;
-    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;
     EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels,
                                               &icons, &unique_ids));
 
-    string16 expected_values[] = { ASCIIToUTF16("Elena") };
-    string16 expected_labels[] = { ASCIIToUTF16("me@x.com") };
-    string16 expected_icons[] = { string16() };
+    base::string16 expected_values[] = { ASCIIToUTF16("Elena") };
+    base::string16 expected_labels[] = { ASCIIToUTF16("me@x.com") };
+    base::string16 expected_icons[] = { base::string16() };
     int expected_unique_ids[] = { 2 };
     ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                       kDefaultPageID, arraysize(expected_values),
                       expected_values, expected_labels, expected_icons,
                       expected_unique_ids);
   }
 }
 
 // Test that all values are suggested for multi-valued profile, on a filled
 // form.  This is the per-field "override" case.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsForMultiValuedProfileFilled) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
   AutofillProfile* profile = new AutofillProfile;
   profile->set_guid("00000000-0000-0000-0000-000000000102");
-  std::vector<string16> multi_values(3);
+  std::vector<base::string16> multi_values(3);
   multi_values[0] = ASCIIToUTF16("Travis Smith");
   multi_values[1] = ASCIIToUTF16("Cynthia Love");
   multi_values[2] = ASCIIToUTF16("Zac Mango");
   profile->SetRawMultiInfo(NAME_FULL, multi_values);
   autofill_manager_->AddProfile(profile);
 
   // Get the first name field.  And start out with "Travis", hoping for all the
   // multi-valued variants as suggestions.
   FormFieldData& field = form.fields[0];
   field.value = ASCIIToUTF16("Travis");
   field.is_autofilled = true;
   GetAutofillSuggestions(form, field);
 
   // Trigger the |Send|.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   EXPECT_TRUE(GetAutofillSuggestionsMessage(&page_id, &values, &labels, &icons,
                                             &unique_ids));
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("Travis"),
     ASCIIToUTF16("Cynthia"),
     ASCIIToUTF16("Zac")
   };
-  string16 expected_labels[] = { string16(), string16(), string16() };
-  string16 expected_icons[] = { string16(), string16(), string16() };
+  base::string16 expected_labels[] = { base::string16(), base::string16(),
+                                       base::string16() };
+  base::string16 expected_icons[] = { base::string16(), base::string16(),
+                                      base::string16() };
   int expected_unique_ids[] = { 1, 2, 3 };
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 TEST_F(AutofillManagerTest, GetProfileSuggestionsFancyPhone) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   AutofillProfile* profile = new AutofillProfile;
   profile->set_guid("00000000-0000-0000-0000-000000000103");
-  std::vector<string16> multi_values(1);
+  std::vector<base::string16> multi_values(1);
   multi_values[0] = ASCIIToUTF16("Natty Bumppo");
   profile->SetRawMultiInfo(NAME_FULL, multi_values);
   multi_values[0] = ASCIIToUTF16("1800PRAIRIE");
   profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, multi_values);
   autofill_manager_->AddProfile(profile);
 
   const FormFieldData& field = form.fields[9];
   GetAutofillSuggestions(form, field);
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
-  AutocompleteSuggestionsReturned(std::vector<string16>());
+  AutocompleteSuggestionsReturned(std::vector<base::string16>());
 
   // Test that we sent the right message to the renderer.
   int page_id = 0;
-  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;
   GetAutofillSuggestionsMessage(
       &page_id, &values, &labels, &icons, &unique_ids);
 
-  string16 expected_values[] = {
+  base::string16 expected_values[] = {
     ASCIIToUTF16("12345678901"),
     ASCIIToUTF16("23456789012"),
     ASCIIToUTF16("18007724743"),  // 1800PRAIRIE
   };
   // Inferred labels include full first relevant field, which in this case is
   // the address line 1.
-  string16 expected_labels[] = {
+  base::string16 expected_labels[] = {
     ASCIIToUTF16("Elvis Aaron Presley"),
     ASCIIToUTF16("Charles Hardin Holley"),
     ASCIIToUTF16("Natty Bumppo"),
   };
-  string16 expected_icons[] = {string16(), string16(), string16()};
+  base::string16 expected_icons[] = { base::string16(), base::string16(),
+                                      base::string16()};
   int expected_unique_ids[] = {1, 2, 3};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we correctly fill an address form.
 TEST_F(AutofillManagerTest, FillAddressForm) {
   // Set up our form data.
   FormData form;
@@ skipping 213 matching lines @@
 
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   {
     SCOPED_TRACE("Address 1");
 
     // The second address section should be empty.
     ASSERT_EQ(results.fields.size(), 2*kAddressFormSize);
     for (size_t i = kAddressFormSize; i < form.fields.size(); ++i) {
-      EXPECT_EQ(string16(), results.fields[i].value);
+      EXPECT_EQ(base::string16(), results.fields[i].value);
     }
 
     // The first address section should be filled with Elvis's data.
     results.fields.resize(kAddressFormSize);
     ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
   }
 
   // Fill the second section, with the initiating field somewhere in the middle
   // of the section.
   const int kPageID2 = 2;
   GUIDPair guid2("00000000-0000-0000-0000-000000000001", 0);
   ASSERT_LT(9U, kAddressFormSize);
   FillAutofillFormData(kPageID2, form, form.fields[kAddressFormSize + 9],
                        PackGUIDs(empty, guid2));
 
   page_id = 0;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   {
     SCOPED_TRACE("Address 2");
     ASSERT_EQ(results.fields.size(), form.fields.size());
 
     // The first address section should be empty.
     ASSERT_EQ(results.fields.size(), 2*kAddressFormSize);
     for (size_t i = 0; i < kAddressFormSize; ++i) {
-      EXPECT_EQ(string16(), results.fields[i].value);
+      EXPECT_EQ(base::string16(), results.fields[i].value);
     }
 
     // The second address section should be filled with Elvis's data.
     FormData secondSection = results;
     secondSection.fields.erase(secondSection.fields.begin(),
                                secondSection.fields.begin() + kAddressFormSize);
     for (size_t i = 0; i < kAddressFormSize; ++i) {
       // Restore the expected field names.
-      string16 name = secondSection.fields[i].name;
-      string16 original_name = name.substr(0, name.size() - 1);
+      base::string16 name = secondSection.fields[i].name;
+      base::string16 original_name = name.substr(0, name.size() - 1);
       secondSection.fields[i].name = original_name;
     }
     ExpectFilledAddressFormElvis(page_id, secondSection, kPageID2, false);
   }
 }
 
 // Test that we correctly fill a form that has author-specified sections, which
 // might not match our expected section breakdown.
 TEST_F(AutofillManagerTest, FillFormWithAuthorSpecifiedSections) {
   // Create a form with a billing section and an unnamed section, interleaved.
@@ skipping 252 matching lines @@
 TEST_F(AutofillManagerTest, FillAddressFormWithVariantType) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Add a name variant to the Elvis profile.
   AutofillProfile* profile = autofill_manager_->GetProfileWithGUID(
       "00000000-0000-0000-0000-000000000001");
-  const string16 elvis_name = profile->GetRawInfo(NAME_FULL);
+  const base::string16 elvis_name = profile->GetRawInfo(NAME_FULL);
 
-  std::vector<string16> name_variants;
+  std::vector<base::string16> name_variants;
   name_variants.push_back(ASCIIToUTF16("Some Other Guy"));
   name_variants.push_back(elvis_name);
   profile->SetRawMultiInfo(NAME_FULL, name_variants);
 
   GUIDPair guid(profile->guid(), 1);
   GUIDPair empty(std::string(), 0);
   FillAutofillFormData(kDefaultPageID, form, form.fields[0],
                        PackGUIDs(empty, guid));
 
   int page_id = 0;
@@ skipping 85 matching lines @@
   page_id = 0;
   FormData results1;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results1));
   EXPECT_EQ(1, page_id);
 
   ASSERT_EQ(5U, results1.fields.size());
   EXPECT_EQ(ASCIIToUTF16("1"), results1.fields[0].value);
   EXPECT_EQ(ASCIIToUTF16("650"), results1.fields[1].value);
   EXPECT_EQ(ASCIIToUTF16("555"), results1.fields[2].value);
   EXPECT_EQ(ASCIIToUTF16("4567"), results1.fields[3].value);
-  EXPECT_EQ(string16(), results1.fields[4].value);
+  EXPECT_EQ(base::string16(), results1.fields[4].value);
 
   page_id = 2;
   FillAutofillFormData(page_id, form_with_autocompletetype,
                        *form_with_autocompletetype.fields.begin(),
                        PackGUIDs(empty, guid));
   page_id = 0;
   FormData results2;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results2));
   EXPECT_EQ(2, page_id);
 
   ASSERT_EQ(5U, results2.fields.size());
   EXPECT_EQ(ASCIIToUTF16("1"), results2.fields[0].value);
   EXPECT_EQ(ASCIIToUTF16("650"), results2.fields[1].value);
   EXPECT_EQ(ASCIIToUTF16("555"), results2.fields[2].value);
   EXPECT_EQ(ASCIIToUTF16("4567"), results2.fields[3].value);
-  EXPECT_EQ(string16(), results2.fields[4].value);
+  EXPECT_EQ(base::string16(), results2.fields[4].value);
 
   // We should not be able to fill prefix and suffix fields for international
   // numbers.
   work_profile->SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("GB"));
   work_profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
                            ASCIIToUTF16("447700954321"));
   page_id = 3;
   FillAutofillFormData(page_id, form_with_maxlength,
                        *form_with_maxlength.fields.begin(),
                        PackGUIDs(empty, guid));
   page_id = 0;
   FormData results3;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results3));
   EXPECT_EQ(3, page_id);
 
   ASSERT_EQ(5U, results3.fields.size());
   EXPECT_EQ(ASCIIToUTF16("44"), results3.fields[0].value);
   EXPECT_EQ(ASCIIToUTF16("7700"), results3.fields[1].value);
   EXPECT_EQ(ASCIIToUTF16("954321"), results3.fields[2].value);
   EXPECT_EQ(ASCIIToUTF16("954321"), results3.fields[3].value);
-  EXPECT_EQ(string16(), results3.fields[4].value);
+  EXPECT_EQ(base::string16(), results3.fields[4].value);
 
   page_id = 4;
   FillAutofillFormData(page_id, form_with_autocompletetype,
                        *form_with_autocompletetype.fields.begin(),
                        PackGUIDs(empty, guid));
   page_id = 0;
   FormData results4;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results4));
   EXPECT_EQ(4, page_id);
 
   ASSERT_EQ(5U, results4.fields.size());
   EXPECT_EQ(ASCIIToUTF16("44"), results4.fields[0].value);
   EXPECT_EQ(ASCIIToUTF16("7700"), results4.fields[1].value);
   EXPECT_EQ(ASCIIToUTF16("954321"), results4.fields[2].value);
   EXPECT_EQ(ASCIIToUTF16("954321"), results4.fields[3].value);
-  EXPECT_EQ(string16(), results4.fields[4].value);
+  EXPECT_EQ(base::string16(), results4.fields[4].value);
 
   // We should fill all phone fields with the same phone number variant.
-  std::vector<string16> phone_variants;
+  std::vector<base::string16> phone_variants;
   phone_variants.push_back(ASCIIToUTF16("16505554567"));
   phone_variants.push_back(ASCIIToUTF16("18887771234"));
   work_profile->SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
   work_profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, phone_variants);
 
   page_id = 5;
   GUIDPair variant_guid(work_profile->guid(), 1);
   FillAutofillFormData(page_id, form_with_maxlength,
                        *form_with_maxlength.fields.begin(),
                        PackGUIDs(empty, variant_guid));
   page_id = 0;
   FormData results5;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results5));
   EXPECT_EQ(5, page_id);
 
   ASSERT_EQ(5U, results5.fields.size());
   EXPECT_EQ(ASCIIToUTF16("1"), results5.fields[0].value);
   EXPECT_EQ(ASCIIToUTF16("888"), results5.fields[1].value);
   EXPECT_EQ(ASCIIToUTF16("777"), results5.fields[2].value);
   EXPECT_EQ(ASCIIToUTF16("1234"), results5.fields[3].value);
-  EXPECT_EQ(string16(), results5.fields[4].value);
+  EXPECT_EQ(base::string16(), results5.fields[4].value);
 }
 
 // Test that we can still fill a form when a field has been removed from it.
 TEST_F(AutofillManagerTest, FormChangesRemoveField) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
 
   // Add a field -- we'll remove it again later.
   FormFieldData field;
@@ skipping 699 matching lines @@
 
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   autofill_manager_->SetExternalDelegate(NULL);
 }