Convert string16 -> base::string16 in components/

components/autofill/browser/autofill_external_delegate_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 <vector>
 
 #include "base/compiler_specific.h"
 #include "base/string16.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 34 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockAutofillExternalDelegate);
 };
 
 class MockAutofillManagerDelegate
     : public autofill::TestAutofillManagerDelegate {
  public:
   MockAutofillManagerDelegate() {}
 
   MOCK_METHOD6(ShowAutofillPopup,
                void(const gfx::RectF& element_bounds,
-                    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>& identifiers,
                     AutofillPopupDelegate* delegate));
 
   MOCK_METHOD0(HideAutofillPopup, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutofillManagerDelegate);
 };
 
 class MockAutofillManager : public AutofillManager {
@@ skipping 77 matching lines @@
               ShowAutofillPopup(
                   _, _, _, _,
                   testing::ElementsAre(
                       kAutofillProfileId,
                       static_cast<int>(WebAutofillClient::MenuItemIDSeparator),
                       static_cast<int>(
                           WebAutofillClient::MenuItemIDAutofillOptions)),
                   external_delegate_.get()));
 
   // This should call ShowAutofillPopup.
-  std::vector<string16> autofill_item;
-  autofill_item.push_back(string16());
+  std::vector<base::string16> autofill_item;
+  autofill_item.push_back(base::string16());
   std::vector<int> autofill_ids;
   autofill_ids.push_back(kAutofillProfileId);
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_item,
                                             autofill_item,
                                             autofill_item,
                                             autofill_ids);
 
   // Called by DidAutofillSuggestions, add expectation to remove warning.
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _));
 
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
 
   // This should trigger a call to hide the popup since we've selected an
   // option.
   external_delegate_->DidAcceptSuggestion(autofill_item[0], autofill_ids[0]);
 }
 
 // Test that data list elements for a node will appear in the Autofill popup.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateDataList) {
   IssueOnQuery(kQueryId);
 
-  std::vector<string16> data_list_items;
-  data_list_items.push_back(string16());
+  std::vector<base::string16> data_list_items;
+  data_list_items.push_back(base::string16());
   std::vector<int> data_list_ids;
   data_list_ids.push_back(WebAutofillClient::MenuItemIDDataListEntry);
 
   external_delegate_->SetCurrentDataListValues(data_list_items,
                                                data_list_items,
                                                data_list_items,
                                                data_list_ids);
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
   EXPECT_CALL(manager_delegate_,
               ShowAutofillPopup(
                   _, _, _, _,
                   testing::ElementsAre(
                       static_cast<int>(
                           WebAutofillClient::MenuItemIDDataListEntry),
                       static_cast<int>(WebAutofillClient::MenuItemIDSeparator),
                       kAutofillProfileId,
                       static_cast<int>(WebAutofillClient::MenuItemIDSeparator),
                       static_cast<int>(
                           WebAutofillClient::MenuItemIDAutofillOptions)),
                       external_delegate_.get()));
 
   // This should call ShowAutofillPopup.
-  std::vector<string16> autofill_item;
-  autofill_item.push_back(string16());
+  std::vector<base::string16> autofill_item;
+  autofill_item.push_back(base::string16());
   std::vector<int> autofill_ids;
   autofill_ids.push_back(kAutofillProfileId);
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_item,
                                             autofill_item,
                                             autofill_item,
                                             autofill_ids);
 
   // Try calling OnSuggestionsReturned with no Autofill values and ensure
   // the datalist items are still shown.
   // The enum must be cast to an int to prevent compile errors on linux_rel.
   EXPECT_CALL(manager_delegate_,
               ShowAutofillPopup(
                   _, _, _, _,
                   testing::ElementsAre(
                       static_cast<int>(
                           WebAutofillClient::MenuItemIDDataListEntry)),
                   external_delegate_.get()));
 
-  autofill_item = std::vector<string16>();
+  autofill_item = std::vector<base::string16>();
   autofill_ids = std::vector<int>();
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_item,
                                             autofill_item,
                                             autofill_item,
                                             autofill_ids);
 }
 
 // Test that the Autofill delegate doesn't try and fill a form with a
 // negative unique id.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateInvalidUniqueId) {
   // Ensure it doesn't try to preview the negative id.
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _)).Times(0);
   EXPECT_CALL(*external_delegate_, ClearPreviewedForm()).Times(1);
   external_delegate_->DidSelectSuggestion(-1);
 
   // Ensure it doesn't try to fill the form in with the negative id.
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _)).Times(0);
-  external_delegate_->DidAcceptSuggestion(string16(), -1);
+  external_delegate_->DidAcceptSuggestion(base::string16(), -1);
 }
 
 // Test that the ClearPreview IPC is only sent the form was being previewed
 // (i.e. it isn't autofilling a password).
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateClearPreviewedForm) {
   // Called by DidSelectSuggestion, add expectation to remove warning.
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _));
 
   // Ensure selecting a new password entries or Autofill entries will
   // cause any previews to get cleared.
@@ skipping 11 matching lines @@
   EXPECT_CALL(manager_delegate_, ShowAutofillPopup(_, _, _, _, _, _));
   autofill::GenerateTestAutofillPopup(external_delegate_.get());
 
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
   external_delegate_->DidEndTextFieldEditing();
 }
 
 // Test that the popup is marked as visible after recieving password
 // suggestions.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegatePasswordSuggestions) {
-  std::vector<string16> suggestions;
-  suggestions.push_back(string16());
+  std::vector<base::string16> suggestions;
+  suggestions.push_back(base::string16());
 
   FormFieldData field;
   field.is_focusable = true;
   field.should_autocomplete = true;
   const gfx::RectF element_bounds;
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
   EXPECT_CALL(manager_delegate_,
               ShowAutofillPopup(
                   _, _, _, _,
@@ skipping 21 matching lines @@
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateHideWarning) {
   // Set up a field that shouldn't get autocompleted or display warnings.
   const FormData form;
   FormFieldData field;
   field.is_focusable = true;
   field.should_autocomplete = false;
   const gfx::RectF element_bounds;
 
   external_delegate_->OnQuery(kQueryId, form, field, element_bounds, false);
 
-  std::vector<string16> autofill_items;
-  autofill_items.push_back(string16());
+  std::vector<base::string16> autofill_items;
+  autofill_items.push_back(base::string16());
   std::vector<int> autofill_ids;
   autofill_ids.push_back(WebAutofillClient::MenuItemIDAutocompleteEntry);
 
   // Ensure the popup tries to hide itself, since it is not allowed to show
   // anything.
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
 
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_items,
                                             autofill_items,
                                             autofill_items,
                                             autofill_ids);
 }