Replace string16 with base::string16.

chrome/browser/autocomplete/history_quick_provider_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 "chrome/browser/autocomplete/history_quick_provider.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <string>
@@ skipping 114 matching lines @@
   virtual void TearDown();
 
   virtual void GetTestData(size_t* data_count, TestURLInfo** test_data);
 
   // Fills test data into the history system.
   void FillData();
 
   // Runs an autocomplete query on |text| and checks to see that the returned
   // results' destination URLs match those provided. |expected_urls| does not
   // need to be in sorted order.
-  void RunTest(const string16 text,
+  void RunTest(const base::string16 text,
                std::vector<std::string> expected_urls,
                bool can_inline_top_result,
-               string16 expected_fill_into_edit);
+               base::string16 expected_fill_into_edit);
 
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   scoped_ptr<TestingProfile> profile_;
   HistoryService* history_service_;
 
   ACMatches ac_matches_;  // The resulting matches after running RunTest.
 
@@ skipping 81 matching lines @@
     matches_.insert(iter->destination_url.spec());
 }
 
 void HistoryQuickProviderTest::SetShouldContain::operator()(
     const std::string& expected) {
   EXPECT_EQ(1U, matches_.erase(expected))
       << "Results did not contain '" << expected << "' but should have.";
 }
 
 
-void HistoryQuickProviderTest::RunTest(const string16 text,
+void HistoryQuickProviderTest::RunTest(const base::string16 text,
                                        std::vector<std::string> expected_urls,
                                        bool can_inline_top_result,
-                                       string16 expected_fill_into_edit) {
+                                       base::string16 expected_fill_into_edit) {
   SCOPED_TRACE(text);  // Minimal hint to query being run.
   base::MessageLoop::current()->RunUntilIdle();
-  AutocompleteInput input(text, string16::npos, string16(), GURL(),
-                          AutocompleteInput::INVALID_SPEC, false, false, true,
-                          AutocompleteInput::ALL_MATCHES);
+  AutocompleteInput input(text, base::string16::npos, base::string16(),
+                          GURL(), AutocompleteInput::INVALID_SPEC, false,
+                          false, true, AutocompleteInput::ALL_MATCHES);
   provider_->Start(input, false);
   EXPECT_TRUE(provider_->done());
 
   ac_matches_ = provider_->matches();
 
   // We should have gotten back at most AutocompleteProvider::kMaxMatches.
   EXPECT_LE(ac_matches_.size(), AutocompleteProvider::kMaxMatches);
 
   // If the number of expected and actual matches aren't equal then we need
   // test no further, but let's do anyway so that we know which URLs failed.
@@ skipping 28 matching lines @@
   }
 
   EXPECT_EQ(can_inline_top_result, ac_matches_[0].allowed_to_be_default_match);
   if (can_inline_top_result) {
     // When the top scorer is inline-able make sure we get the expected
     // fill_into_edit and autocomplete offset.
     EXPECT_EQ(expected_fill_into_edit, ac_matches_[0].fill_into_edit)
         << "fill_into_edit was: '" << ac_matches_[0].fill_into_edit
         << "' but we expected '" << expected_fill_into_edit << "'.";
     size_t text_pos = expected_fill_into_edit.find(text);
-    ASSERT_NE(string16::npos, text_pos);
+    ASSERT_NE(base::string16::npos, text_pos);
     EXPECT_EQ(ac_matches_[0].fill_into_edit.substr(text_pos + text.size()),
               ac_matches_[0].inline_autocompletion);
   } else {
     // When the top scorer is not inline-able autocomplete offset must be npos.
     EXPECT_TRUE(ac_matches_[0].inline_autocompletion.empty());
     // Also, the score must be too low to be inlineable.
     // TODO(mpearson): when the controller reorders for inlining, there's no
     // longer any connection between scores and what's inlineable / allowed
     // to be the default match.  Remove this test.
     EXPECT_LT(ac_matches_[0].relevance,
@@ skipping 240 matching lines @@
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile_.get());
   TemplateURL* template_url = new TemplateURL(profile_.get(), data);
   template_url_service->Add(template_url);
   template_url_service->SetDefaultSearchProvider(template_url);
   template_url_service->Load();
 
   // A search results page should not be returned when typing a query.
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://anotherengine.com/?q=thequery");
-  RunTest(ASCIIToUTF16("thequery"), expected_urls, false, string16());
+  RunTest(ASCIIToUTF16("thequery"), expected_urls, false, base::string16());
 
   // A search results page should not be returned when typing the engine URL.
   expected_urls.clear();
   expected_urls.push_back("http://testsearch.com/");
   RunTest(ASCIIToUTF16("testsearch"), expected_urls, true,
           ASCIIToUTF16("testsearch.com"));
 }
 
 // HQPOrderingTest -------------------------------------------------------------
 
@@ skipping 55 matching lines @@
 }
 
 TEST_F(HQPOrderingTest, TEAMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://www.teamliquid.net/");
   expected_urls.push_back("http://www.teamliquid.net/tlpd");
   expected_urls.push_back("http://www.teamliquid.net/tlpd/korean/players");
   RunTest(ASCIIToUTF16("tea"), expected_urls, true,
           ASCIIToUTF16("www.teamliquid.net"));
 }