Replace string16 with base::string16.

chrome/browser/autocomplete/autocomplete_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/autocomplete_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 26 matching lines @@
 
 namespace {
 const size_t kResultsPerProvider = 3;
 const char kTestTemplateURLKeyword[] = "t";
 }
 
 // Autocomplete provider that provides known results. Note that this is
 // refcounted so that it can also be a task on the message loop.
 class TestProvider : public AutocompleteProvider {
  public:
-  TestProvider(int relevance, const string16& prefix,
+  TestProvider(int relevance, const base::string16& prefix,
                Profile* profile,
-               const string16 match_keyword)
+               const base::string16 match_keyword)
       : AutocompleteProvider(NULL, profile, AutocompleteProvider::TYPE_SEARCH),
         relevance_(relevance),
         prefix_(prefix),
         match_keyword_(match_keyword) {
   }
 
   virtual void Start(const AutocompleteInput& input,
                      bool minimal_changes) OVERRIDE;
 
   void set_listener(AutocompleteProviderListener* listener) {
     listener_ = listener;
   }
 
  private:
   virtual ~TestProvider() {}
 
   void Run();
 
   void AddResults(int start_at, int num);
   void AddResultsWithSearchTermsArgs(
       int start_at,
       int num,
       AutocompleteMatch::Type type,
       const TemplateURLRef::SearchTermsArgs& search_terms_args);
 
   int relevance_;
-  const string16 prefix_;
-  const string16 match_keyword_;
+  const base::string16 prefix_;
+  const base::string16 match_keyword_;
 };
 
 void TestProvider::Start(const AutocompleteInput& input,
                          bool minimal_changes) {
   if (minimal_changes)
     return;
 
   matches_.clear();
 
   // Generate 4 results synchronously, the rest later.
@@ skipping 20 matching lines @@
   AddResults(1, kResultsPerProvider);
   done_ = true;
   DCHECK(listener_);
   listener_->OnProviderUpdate(true);
 }
 
 void TestProvider::AddResults(int start_at, int num) {
   AddResultsWithSearchTermsArgs(start_at,
                                 num,
                                 AutocompleteMatchType::URL_WHAT_YOU_TYPED,
-                                TemplateURLRef::SearchTermsArgs(string16()));
+                                TemplateURLRef::SearchTermsArgs(
+                                    base::string16()));
 }
 
 void TestProvider::AddResultsWithSearchTermsArgs(
     int start_at,
     int num,
     AutocompleteMatch::Type type,
     const TemplateURLRef::SearchTermsArgs& search_terms_args) {
   for (int i = start_at; i < num; i++) {
     AutocompleteMatch match(this, relevance_ - i, false, type);
 
@@ skipping 15 matching lines @@
     }
 
     matches_.push_back(match);
   }
 }
 
 class AutocompleteProviderTest : public testing::Test,
                                  public content::NotificationObserver {
  protected:
   struct KeywordTestData {
-    const string16 fill_into_edit;
-    const string16 keyword;
+    const base::string16 fill_into_edit;
+    const base::string16 keyword;
     const bool expected_keyword_result;
   };
 
   struct AssistedQueryStatsTestData {
     const AutocompleteMatch::Type match_type;
     const std::string expected_aqs;
   };
 
  protected:
    // Registers a test TemplateURL under the given keyword.
-  void RegisterTemplateURL(const string16 keyword,
+  void RegisterTemplateURL(const base::string16 keyword,
                            const std::string& template_url);
 
   // Resets |controller_| with two TestProviders.  |provider1_ptr| and
   // |provider2_ptr| are updated to point to the new providers if non-NULL.
   void ResetControllerWithTestProviders(bool same_destinations,
                                         TestProvider** provider1_ptr,
                                         TestProvider** provider2_ptr);
 
   // Runs a query on the input "a", and makes sure both providers' input is
   // properly collected.
   void RunTest();
 
   void RunRedundantKeywordTest(const KeywordTestData* match_data, size_t size);
 
   void RunAssistedQueryStatsTest(
       const AssistedQueryStatsTestData* aqs_test_data,
       size_t size);
 
-  void RunQuery(const string16 query);
+  void RunQuery(const base::string16 query);
 
   void ResetControllerWithKeywordAndSearchProviders();
   void ResetControllerWithKeywordProvider();
   void RunExactKeymatchTest(bool allow_exact_keyword_match);
 
   void CopyResults();
 
   // Returns match.destination_url as it would be set by
   // AutocompleteController::UpdateMatchDestinationURL().
   GURL GetDestinationURL(AutocompleteMatch match,
                          base::TimeDelta query_formulation_time) const;
 
   AutocompleteResult result_;
   scoped_ptr<AutocompleteController> controller_;
 
  private:
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   base::MessageLoopForUI message_loop_;
   content::NotificationRegistrar registrar_;
   TestingProfile profile_;
 };
 
 void AutocompleteProviderTest::RegisterTemplateURL(
-    const string16 keyword,
+    const base::string16 keyword,
     const std::string& template_url) {
   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
   TemplateURLData data;
   data.SetURL(template_url);
   data.SetKeyword(keyword);
   TemplateURL* default_t_url = new TemplateURL(&profile_, data);
   TemplateURLService* turl_model =
       TemplateURLServiceFactory::GetForProfile(&profile_);
   turl_model->Add(default_t_url);
@@ skipping 28 matching lines @@
       ASCIIToUTF16("http://a"),
       &profile_,
       ASCIIToUTF16(kTestTemplateURLKeyword));
   provider1->AddRef();
   providers.push_back(provider1);
 
   TestProvider* provider2 = new TestProvider(
       kResultsPerProvider * 2,
       same_destinations ? ASCIIToUTF16("http://a") : ASCIIToUTF16("http://b"),
       &profile_,
-      string16());
+      base::string16());
   provider2->AddRef();
   providers.push_back(provider2);
 
   // Reset the controller to contain our new providers.
   controller_.reset(new AutocompleteController(&profile_, NULL, 0));
   // We're going to swap the providers vector, but the old vector should be
   // empty so no elements need to be freed at this point.
   EXPECT_TRUE(controller_->providers_.empty());
   controller_->providers_.swap(providers);
   provider1->set_listener(controller_.get());
@@ skipping 101 matching lines @@
     size_t size) {
   // Prepare input.
   const size_t kMaxRelevance = 1000;
   ACMatches matches;
   for (size_t i = 0; i < size; ++i) {
     AutocompleteMatch match(NULL, kMaxRelevance - i, false,
                             aqs_test_data[i].match_type);
     match.allowed_to_be_default_match = true;
     match.keyword = ASCIIToUTF16(kTestTemplateURLKeyword);
     match.search_terms_args.reset(
-        new TemplateURLRef::SearchTermsArgs(string16()));
+        new TemplateURLRef::SearchTermsArgs(base::string16()));
     matches.push_back(match);
   }
   result_.Reset();
   result_.AppendMatches(matches);
 
   // Update AQS.
   controller_->UpdateAssistedQueryStats(&result_);
 
   // Verify data.
   for (size_t i = 0; i < size; ++i) {
     EXPECT_EQ(aqs_test_data[i].expected_aqs,
               result_.match_at(i)->search_terms_args->assisted_query_stats);
   }
 }
 
-void AutocompleteProviderTest::RunQuery(const string16 query) {
+void AutocompleteProviderTest::RunQuery(const base::string16 query) {
   result_.Reset();
   controller_->Start(AutocompleteInput(
-      query, string16::npos, string16(), GURL(),
+      query, base::string16::npos, base::string16(), GURL(),
       AutocompleteInput::INVALID_SPEC, true, false, true,
       AutocompleteInput::ALL_MATCHES));
 
   if (!controller_->done())
     // The message loop will terminate when all autocomplete input has been
     // collected.
     base::MessageLoop::current()->Run();
 }
 
 void AutocompleteProviderTest::RunExactKeymatchTest(
     bool allow_exact_keyword_match) {
   // Send the controller input which exactly matches the keyword provider we
   // created in ResetControllerWithKeywordAndSearchProviders().  The default
   // match should thus be a search-other-engine match iff
   // |allow_exact_keyword_match| is true.  Regardless, the match should
   // be from SearchProvider.  (It provides all verbatim search matches,
   // keyword or not.)
   controller_->Start(AutocompleteInput(
-      ASCIIToUTF16("k test"), string16::npos, string16(), GURL(),
+      ASCIIToUTF16("k test"), base::string16::npos, base::string16(), GURL(),
       AutocompleteInput::INVALID_SPEC, true, false, allow_exact_keyword_match,
       AutocompleteInput::SYNCHRONOUS_MATCHES));
   EXPECT_TRUE(controller_->done());
   EXPECT_EQ(AutocompleteProvider::TYPE_SEARCH,
       controller_->result().default_match()->provider->type());
   EXPECT_EQ(allow_exact_keyword_match ?
       AutocompleteMatchType::SEARCH_OTHER_ENGINE :
       AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
       controller_->result().default_match()->type);
 }
@@ skipping 87 matching lines @@
   EXPECT_EQ("http://defaultturl/k%20test?a=b",
             result_.match_at(1)->destination_url.possibly_invalid_spec());
 }
 
 // Test that redundant associated keywords are removed.
 TEST_F(AutocompleteProviderTest, RedundantKeywordsIgnoredInResult) {
   ResetControllerWithKeywordProvider();
 
   {
     KeywordTestData duplicate_url[] = {
-      { ASCIIToUTF16("fo"), string16(), false },
-      { ASCIIToUTF16("foo.com"), string16(), true },
-      { ASCIIToUTF16("foo.com"), string16(), false }
+      { ASCIIToUTF16("fo"), base::string16(), false },
+      { ASCIIToUTF16("foo.com"), base::string16(), true },
+      { ASCIIToUTF16("foo.com"), base::string16(), false }
     };
 
     SCOPED_TRACE("Duplicate url");
     RunRedundantKeywordTest(duplicate_url, ARRAYSIZE_UNSAFE(duplicate_url));
   }
 
   {
     KeywordTestData keyword_match[] = {
       { ASCIIToUTF16("foo.com"), ASCIIToUTF16("foo.com"), false },
-      { ASCIIToUTF16("foo.com"), string16(), false }
+      { ASCIIToUTF16("foo.com"), base::string16(), false }
     };
 
     SCOPED_TRACE("Duplicate url with keyword match");
     RunRedundantKeywordTest(keyword_match, ARRAYSIZE_UNSAFE(keyword_match));
   }
 
   {
     KeywordTestData multiple_keyword[] = {
-      { ASCIIToUTF16("fo"), string16(), false },
-      { ASCIIToUTF16("foo.com"), string16(), true },
-      { ASCIIToUTF16("foo.com"), string16(), false },
-      { ASCIIToUTF16("bar.com"), string16(), true },
+      { ASCIIToUTF16("fo"), base::string16(), false },
+      { ASCIIToUTF16("foo.com"), base::string16(), true },
+      { ASCIIToUTF16("foo.com"), base::string16(), false },
+      { ASCIIToUTF16("bar.com"), base::string16(), true },
     };
 
     SCOPED_TRACE("Duplicate url with multiple keywords");
     RunRedundantKeywordTest(multiple_keyword,
         ARRAYSIZE_UNSAFE(multiple_keyword));
   }
 }
 
 TEST_F(AutocompleteProviderTest, UpdateAssistedQueryStats) {
   ResetControllerWithTestProviders(false, NULL, NULL);
@@ skipping 56 matching lines @@
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_TRUE(url.path().empty());
 
   // There needs to be a keyword provider.
   match.keyword = ASCIIToUTF16(kTestTemplateURLKeyword);
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_TRUE(url.path().empty());
 
   // search_terms_args needs to be set.
   match.search_terms_args.reset(
-      new TemplateURLRef::SearchTermsArgs(string16()));
+      new TemplateURLRef::SearchTermsArgs(base::string16()));
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_TRUE(url.path().empty());
 
   // assisted_query_stats needs to have been previously set.
   match.search_terms_args->assisted_query_stats =
       "chrome.0.69i57j69i58j5l2j0l3j69i59";
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j0j0&", url.path());
 
   // Test field trial triggered bit set.
@@ skipping 11 matching lines @@
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j0j4&", url.path());
 
   // Test page classification and field trial triggered set.
   controller_->search_provider_->field_trial_triggered_in_session_ = true;
   EXPECT_TRUE(
       controller_->search_provider_->field_trial_triggered_in_session());
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j1j4&", url.path());
 }