Replace string16 with base::string16.

chrome/browser/autocomplete/search_provider_unittest.cc

 // Copyright 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/search_provider.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 91 matching lines @@
 class SearchProviderTest : public testing::Test,
                            public AutocompleteProviderListener {
  public:
   struct ResultInfo {
     ResultInfo() : result_type(AutocompleteMatchType::NUM_TYPES),
                    allowed_to_be_default_match(false) {
     }
     ResultInfo(GURL gurl,
                AutocompleteMatch::Type result_type,
                bool allowed_to_be_default_match,
-               string16 fill_into_edit)
+               base::string16 fill_into_edit)
       : gurl(gurl),
         result_type(result_type),
         allowed_to_be_default_match(allowed_to_be_default_match),
         fill_into_edit(fill_into_edit) {
     }
 
     const GURL gurl;
     const AutocompleteMatch::Type result_type;
     const bool allowed_to_be_default_match;
-    const string16 fill_into_edit;
+    const base::string16 fill_into_edit;
   };
 
   struct TestData {
-    const string16 input;
+    const base::string16 input;
     const size_t num_results;
     const ResultInfo output[3];
   };
 
   SearchProviderTest()
       : default_t_url_(NULL),
         term1_(ASCIIToUTF16("term1")),
         keyword_t_url_(NULL),
         keyword_term_(ASCIIToUTF16("keyword")),
         run_loop_(NULL) {
     ResetFieldTrialList();
   }
 
   // See description above class for what this registers.
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   void RunTest(TestData* cases, int num_cases, bool prefer_keyword);
 
  protected:
   // Needed for AutocompleteFieldTrial::ActivateStaticTrials();
   scoped_ptr<base::FieldTrialList> field_trial_list_;
 
   // Default value used for testing.
   static const std::string kNotApplicable;
 
   // Adds a search for |term|, using the engine |t_url| to the history, and
   // returns the URL for that search.
-  GURL AddSearchToHistory(TemplateURL* t_url, string16 term, int visit_count);
+  GURL AddSearchToHistory(TemplateURL* t_url, base::string16 term, int visit_count);
 
   // Looks for a match in |provider_| with |contents| equal to |contents|.
   // Sets |match| to it if found.  Returns whether |match| was set.
-  bool FindMatchWithContents(const string16& contents,
+  bool FindMatchWithContents(const base::string16& contents,
                              AutocompleteMatch* match);
 
   // Looks for a match in |provider_| with destination |url|.  Sets |match| to
   // it if found.  Returns whether |match| was set.
   bool FindMatchWithDestination(const GURL& url, AutocompleteMatch* match);
 
   // AutocompleteProviderListener:
   // If we're waiting for the provider to finish, this exits the message loop.
   virtual void OnProviderUpdate(bool updated_matches) OVERRIDE;
 
   // Runs a nested message loop until provider_ is done. The message loop is
   // exited by way of OnProviderUpdate.
   void RunTillProviderDone();
 
   // Invokes Start on provider_, then runs all pending tasks.
-  void QueryForInput(const string16& text,
+  void QueryForInput(const base::string16& text,
                      bool prevent_inline_autocomplete,
                      bool prefer_keyword);
 
   // Calls QueryForInput(), finishes any suggest query, then if |wyt_match| is
   // non-NULL, sets it to the "what you typed" entry for |text|.
-  void QueryForInputAndSetWYTMatch(const string16& text,
+  void QueryForInputAndSetWYTMatch(const base::string16& text,
                                    AutocompleteMatch* wyt_match);
 
   // Notifies the URLFetcher for the suggest query corresponding to the default
   // search provider that it's done.
   // Be sure and wrap calls to this in ASSERT_NO_FATAL_FAILURE.
   void FinishDefaultSuggestQuery();
 
   // Runs SearchProvider on |input|, for which the suggest server replies
   // with |json|, and expects that the resulting matches' contents equals
   // that in |matches|.  An empty entry in |matches| means no match should
   // be returned in that position.  Reports any errors with a message that
   // includes |error_description|.
   void ForcedQueryTestHelper(const std::string& input,
                              const std::string& json,
                              const std::string matches[3],
                              const std::string& error_description);
 
   void ResetFieldTrialList();
 
   void ClearAllResults();
 
   // See description above class for details of these fields.
   TemplateURL* default_t_url_;
-  const string16 term1_;
+  const base::string16 term1_;
   GURL term1_url_;
   TemplateURL* keyword_t_url_;
-  const string16 keyword_term_;
+  const base::string16 keyword_term_;
   GURL keyword_url_;
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   // URLFetcherFactory implementation registered.
   net::TestURLFetcherFactory test_factory_;
 
   // Profile we use.
   TestingProfile profile_;
 
@@ skipping 65 matching lines @@
 
   // Shutdown the provider before the profile.
   provider_ = NULL;
 }
 
 void SearchProviderTest::RunTest(TestData* cases,
                                  int num_cases,
                                  bool prefer_keyword) {
   ACMatches matches;
   for (int i = 0; i < num_cases; ++i) {
-    AutocompleteInput input(cases[i].input, string16::npos, string16(), GURL(),
+    AutocompleteInput input(cases[i].input, base::string16::npos, base::string16(), GURL(),
                             AutocompleteInput::INVALID_SPEC, false,
                             prefer_keyword, true,
                             AutocompleteInput::ALL_MATCHES);
     provider_->Start(input, false);
     matches = provider_->matches();
-    string16 diagnostic_details = ASCIIToUTF16("Input was: ") + cases[i].input +
+    base::string16 diagnostic_details = ASCIIToUTF16("Input was: ") + cases[i].input +
         ASCIIToUTF16("; prefer_keyword was: ") +
         (prefer_keyword ? ASCIIToUTF16("true") : ASCIIToUTF16("false"));
     EXPECT_EQ(cases[i].num_results, matches.size()) << diagnostic_details;
     if (matches.size() == cases[i].num_results) {
       for (size_t j = 0; j < cases[i].num_results; ++j) {
         EXPECT_EQ(cases[i].output[j].gurl, matches[j].destination_url) <<
             diagnostic_details;
         EXPECT_EQ(cases[i].output[j].result_type, matches[j].type) <<
             diagnostic_details;
         EXPECT_EQ(cases[i].output[j].fill_into_edit,
@@ skipping 14 matching lines @@
 
 void SearchProviderTest::RunTillProviderDone() {
   if (provider_->done())
     return;
 
   base::RunLoop run_loop;
   run_loop_ = &run_loop;
   run_loop.Run();
 }
 
-void SearchProviderTest::QueryForInput(const string16& text,
+void SearchProviderTest::QueryForInput(const base::string16& text,
                                        bool prevent_inline_autocomplete,
                                        bool prefer_keyword) {
   // Start a query.
-  AutocompleteInput input(text, string16::npos, string16(), GURL(),
+  AutocompleteInput input(text, base::string16::npos, base::string16(), GURL(),
                           AutocompleteInput::INVALID_SPEC,
                           prevent_inline_autocomplete, prefer_keyword, true,
                           AutocompleteInput::ALL_MATCHES);
   provider_->Start(input, false);
 
   // RunUntilIdle so that the task scheduled by SearchProvider to create the
   // URLFetchers runs.
   base::RunLoop().RunUntilIdle();
 }
 
 void SearchProviderTest::QueryForInputAndSetWYTMatch(
-    const string16& text,
+    const base::string16& text,
     AutocompleteMatch* wyt_match) {
   QueryForInput(text, false, false);
   profile_.BlockUntilHistoryProcessesPendingRequests();
   ASSERT_NO_FATAL_FAILURE(FinishDefaultSuggestQuery());
   if (!wyt_match)
     return;
   ASSERT_GE(provider_->matches().size(), 1u);
   EXPECT_TRUE(FindMatchWithDestination(GURL(
       default_t_url_->url_ref().ReplaceSearchTerms(
           TemplateURLRef::SearchTermsArgs(text))),
       wyt_match));
 }
 
 GURL SearchProviderTest::AddSearchToHistory(TemplateURL* t_url,
-                                            string16 term,
+                                            base::string16 term,
                                             int visit_count) {
   HistoryService* history =
       HistoryServiceFactory::GetForProfile(&profile_,
                                            Profile::EXPLICIT_ACCESS);
   GURL search(t_url->url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(term)));
   static base::Time last_added_time;
   last_added_time = std::max(base::Time::Now(),
       last_added_time + base::TimeDelta::FromMicroseconds(1));
-  history->AddPageWithDetails(search, string16(), visit_count, visit_count,
+  history->AddPageWithDetails(search, base::string16(), visit_count, visit_count,
       last_added_time, false, history::SOURCE_BROWSED);
   history->SetKeywordSearchTermsForURL(search, t_url->id(), term);
   return search;
 }
 
-bool SearchProviderTest::FindMatchWithContents(const string16& contents,
+bool SearchProviderTest::FindMatchWithContents(const base::string16& contents,
                                                AutocompleteMatch* match) {
   for (ACMatches::const_iterator i = provider_->matches().begin();
        i != provider_->matches().end(); ++i) {
     if (i->contents == contents) {
       *match = *i;
       return true;
     }
   }
   return false;
 }
@@ skipping 64 matching lines @@
 
 void SearchProviderTest::ClearAllResults() {
   provider_->ClearAllResults();
 }
 
 // Actual Tests ---------------------------------------------------------------
 
 // Make sure we query history for the default provider and a URLFetcher is
 // created for the default provider suggest results.
 TEST_F(SearchProviderTest, QueryDefaultProvider) {
-  string16 term = term1_.substr(0, term1_.length() - 1);
+  base::string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, false, false);
 
   // Make sure the default providers suggest service was queried.
   net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(fetcher);
 
   // And the URL matches what we expected.
   GURL expected_url(default_t_url_->suggestions_url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(term)));
@@ skipping 22 matching lines @@
 
   // The match for term1 should be more relevant than the what you typed match.
   EXPECT_GT(term1_match.relevance, wyt_match.relevance);
   // This longer match should be inlineable.
   EXPECT_TRUE(term1_match.allowed_to_be_default_match);
   // The what you typed match should be too, of course.
   EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 }
 
 TEST_F(SearchProviderTest, HonorPreventInlineAutocomplete) {
-  string16 term = term1_.substr(0, term1_.length() - 1);
+  base::string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, true, false);
 
   ASSERT_FALSE(provider_->matches().empty());
   ASSERT_EQ(AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
             provider_->matches()[0].type);
   EXPECT_TRUE(provider_->matches()[0].allowed_to_be_default_match);
 }
 
 // Issues a query that matches the registered keyword and makes sure history
 // is queried as well as URLFetchers getting created.
 TEST_F(SearchProviderTest, QueryKeywordProvider) {
-  string16 term = keyword_term_.substr(0, keyword_term_.length() - 1);
+  base::string16 term = keyword_term_.substr(0, keyword_term_.length() - 1);
   QueryForInput(keyword_t_url_->keyword() + ASCIIToUTF16(" ") + term,
                 false,
                 false);
 
   // Make sure the default providers suggest service was queried.
   net::TestURLFetcher* default_fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(default_fetcher);
 
   // Tell the SearchProvider the default suggest query is done.
@@ skipping 85 matching lines @@
 }
 
 TEST_F(SearchProviderTest, DontAutocompleteURLLikeTerms) {
   AutocompleteClassifierFactory::GetInstance()->SetTestingFactoryAndUse(
       &profile_, &AutocompleteClassifierFactory::BuildInstanceFor);
   GURL url = AddSearchToHistory(default_t_url_,
                                 ASCIIToUTF16("docs.google.com"), 1);
 
   // Add the term as a url.
   HistoryServiceFactory::GetForProfile(&profile_, Profile::EXPLICIT_ACCESS)->
-      AddPageWithDetails(GURL("http://docs.google.com"), string16(), 1, 1,
+      AddPageWithDetails(GURL("http://docs.google.com"), base::string16(), 1, 1,
                          base::Time::Now(), false, history::SOURCE_BROWSED);
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteMatch wyt_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("docs"),
                                                       &wyt_match));
 
   // There should be two matches, one for what you typed, the other for
   // 'docs.google.com'. The search term should have a lower priority than the
   // what you typed match.
@@ skipping 211 matching lines @@
 // Verifies AutocompleteControllers return results (including keyword
 // results) in the right order and set descriptions for them correctly.
 TEST_F(SearchProviderTest, KeywordOrderingAndDescriptions) {
   // Add an entry that corresponds to a keyword search with 'term2'.
   AddSearchToHistory(keyword_t_url_, ASCIIToUTF16("term2"), 1);
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteController controller(&profile_, NULL,
       AutocompleteProvider::TYPE_SEARCH);
   controller.Start(AutocompleteInput(
-      ASCIIToUTF16("k t"), string16::npos, string16(), GURL(),
+      ASCIIToUTF16("k t"), base::string16::npos, base::string16(), GURL(),
       AutocompleteInput::INVALID_SPEC, false, false, true,
       AutocompleteInput::ALL_MATCHES));
   const AutocompleteResult& result = controller.result();
 
   // There should be three matches, one for the keyword history, one for
   // keyword provider's what-you-typed, and one for the default provider's
   // what you typed, in that order.
   ASSERT_EQ(3u, result.size());
   EXPECT_EQ(AutocompleteMatchType::SEARCH_HISTORY, result.match_at(0).type);
   EXPECT_EQ(AutocompleteMatchType::SEARCH_OTHER_ENGINE,
@@ skipping 1764 matching lines @@
     for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j)
       EXPECT_EQ(kNotApplicable, cases[i].matches[j].contents) <<
           "Case # " << i << " " << description;
   }
 }
 
 TEST_F(SearchProviderTest, LocalAndRemoteRelevances) {
   // We hardcode the string "term1" below, so ensure that the search term that
   // got added to history already is that string.
   ASSERT_EQ(ASCIIToUTF16("term1"), term1_);
-  string16 term = term1_.substr(0, term1_.length() - 1);
+  base::string16 term = term1_.substr(0, term1_.length() - 1);
 
   AddSearchToHistory(default_t_url_, term + ASCIIToUTF16("2"), 2);
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   struct {
-    const string16 input;
+    const base::string16 input;
     const std::string json;
     const std::string matches[6];
   } cases[] = {
     // The history results outscore the default verbatim score.  term2 has more
     // visits so it outscores term1.  The suggestions are still returned since
     // they're server-scored.
     { term,
       "[\"term\",[\"a1\", \"a2\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"QUERY\", \"QUERY\", \"QUERY\"],"
         "\"google:suggestrelevance\":[1, 2, 3]}]",
@@ skipping 508 matching lines @@
     { "?ab",             "http://www.abc.com",
                                "?www.abc.com", "c.com", true },
     { "?abc.com",        "http://www.abc.com",
                                "?www.abc.com", "", true },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16(cases[i].input), false, false);
     AutocompleteMatch match(
         provider_->NavigationToMatch(SearchProvider::NavigationResult(
-            *provider_.get(), GURL(cases[i].url), string16(), false, 0,
+            *provider_.get(), GURL(cases[i].url), base::string16(), false, 0,
             false)));
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
               match.inline_autocompletion);
     EXPECT_EQ(ASCIIToUTF16(cases[i].fill_into_edit), match.fill_into_edit);
     EXPECT_EQ(cases[i].allowed_to_be_default_match,
               match.allowed_to_be_default_match);
   }
 }
 
 // Verifies that "http://" is not trimmed for input that is a leading substring.
 TEST_F(SearchProviderTest, NavigationInlineSchemeSubstring) {
-  const string16 input(ASCIIToUTF16("ht"));
-  const string16 url(ASCIIToUTF16("http://a.com"));
+  const base::string16 input(ASCIIToUTF16("ht"));
+  const base::string16 url(ASCIIToUTF16("http://a.com"));
   const SearchProvider::NavigationResult result(
-      *provider_.get(), GURL(url), string16(), false, 0, false);
+      *provider_.get(), GURL(url), base::string16(), false, 0, false);
 
   // Check the offset and strings when inline autocompletion is allowed.
   QueryForInput(input, false, false);
   AutocompleteMatch match_inline(provider_->NavigationToMatch(result));
   EXPECT_EQ(url, match_inline.fill_into_edit);
   EXPECT_EQ(url.substr(2), match_inline.inline_autocompletion);
   EXPECT_TRUE(match_inline.allowed_to_be_default_match);
   EXPECT_EQ(url, match_inline.contents);
 
   // Check the same offset and strings when inline autocompletion is prevented.
   QueryForInput(input, true, false);
   AutocompleteMatch match_prevent(provider_->NavigationToMatch(result));
   EXPECT_EQ(url, match_prevent.fill_into_edit);
   EXPECT_TRUE(match_prevent.inline_autocompletion.empty());
   EXPECT_FALSE(match_prevent.allowed_to_be_default_match);
   EXPECT_EQ(url, match_prevent.contents);
 }
 
 // Verifies that input "w" marks a more significant domain label than "www.".
 TEST_F(SearchProviderTest, NavigationInlineDomainClassify) {
   QueryForInput(ASCIIToUTF16("w"), false, false);
   AutocompleteMatch match(
       provider_->NavigationToMatch(SearchProvider::NavigationResult(
-          *provider_.get(), GURL("http://www.wow.com"), string16(), false, 0,
+          *provider_.get(), GURL("http://www.wow.com"), base::string16(), false, 0,
           false)));
   EXPECT_EQ(ASCIIToUTF16("ow.com"), match.inline_autocompletion);
   EXPECT_TRUE(match.allowed_to_be_default_match);
   EXPECT_EQ(ASCIIToUTF16("www.wow.com"), match.fill_into_edit);
   EXPECT_EQ(ASCIIToUTF16("www.wow.com"), match.contents);
 
   // Ensure that the match for input "w" is marked on "wow" and not "www".
   ASSERT_EQ(3U, match.contents_class.size());
   EXPECT_EQ(0U, match.contents_class[0].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
@@ skipping 142 matching lines @@
         cases[i].verbatim_relevance;
     provider_->default_results_.navigation_results.clear();
     provider_->default_results_.suggest_results.clear();
     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(cases[i].results); ++j) {
       const std::string& suggestion = cases[i].results[j].suggestion;
       if (suggestion == kNotApplicable)
         break;
       if (cases[i].results[j].is_navigation_result) {
         provider_->default_results_.navigation_results.push_back(
             SearchProvider::NavigationResult(
-                *provider_.get(), GURL(suggestion), string16(), false,
+                *provider_.get(), GURL(suggestion), base::string16(), false,
                 cases[i].results[j].relevance, false));
       } else {
         provider_->default_results_.suggest_results.push_back(
-            SearchProvider::SuggestResult(ASCIIToUTF16(suggestion), string16(),
-                                          string16(), std::string(),
+            SearchProvider::SuggestResult(ASCIIToUTF16(suggestion), base::string16(),
+                                          base::string16(), std::string(),
                                           std::string(), false,
                                           cases[i].results[j].relevance,
                                           false, false));
       }
     }
 
     provider_->input_ = AutocompleteInput(
-        ASCIIToUTF16(cases[i].omnibox_input), string16::npos, string16(),
+        ASCIIToUTF16(cases[i].omnibox_input), base::string16::npos, base::string16(),
         GURL(), AutocompleteInput::INVALID_SPEC, false, false, true,
         AutocompleteInput::ALL_MATCHES);
     provider_->RemoveAllStaleResults();
 
     // Check cached results.
     SearchProvider::SuggestResults::const_iterator sug_it =
         provider_->default_results_.suggest_results.begin();
     const SearchProvider::SuggestResults::const_iterator sug_end =
         provider_->default_results_.suggest_results.end();
     SearchProvider::NavigationResults::const_iterator nav_it =
@@ skipping 559 matching lines @@
          SCOPED_TRACE(" and match index: " + base::IntToString(j));
          EXPECT_EQ(match.contents, UTF16ToUTF8(matches[j].contents));
          EXPECT_EQ(match.deletion_url, matches[j].GetAdditionalInfo(
              "deletion_url"));
        }
      }
 }
 
 TEST_F(SearchProviderTest, ReflectsBookmarkBarState) {
   profile_.GetPrefs()->SetBoolean(prefs::kShowBookmarkBar, false);
-  string16 term = term1_.substr(0, term1_.length() - 1);
+  base::string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, true, false);
   ASSERT_FALSE(provider_->matches().empty());
   EXPECT_EQ(AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
             provider_->matches()[0].type);
   ASSERT_TRUE(provider_->matches()[0].search_terms_args != NULL);
   EXPECT_FALSE(provider_->matches()[0].search_terms_args->bookmark_bar_pinned);
 
   profile_.GetPrefs()->SetBoolean(prefs::kShowBookmarkBar, true);
   term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, true, false);
@@ skipping 157 matching lines @@
   EXPECT_FALSE(provider_->deletion_handlers_.empty());
   // Set up a default fetcher with provided results.
   fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDeletionURLFetcherID);
   ASSERT_TRUE(fetcher);
   fetcher->set_response_code(500);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   EXPECT_TRUE(provider_->deletion_handlers_.empty());
   EXPECT_FALSE(provider_->is_success());
 }