Remove wstring from TemplateURL and friends....

chrome/browser/autocomplete/search_provider_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/search_provider.h"
 #include "chrome/browser/browser_thread.h"
@@ skipping 97 matching lines @@
   default_t_url_->SetSuggestionsURL("http://defaultturl2/{searchTerms}", 0, 0);
   turl_model->Add(default_t_url_);
   turl_model->SetDefaultSearchProvider(default_t_url_);
   TemplateURLID default_provider_id = default_t_url_->id();
   ASSERT_NE(0, default_provider_id);
 
   // Add url1, with search term term1_.
   HistoryService* history =
       profile_.GetHistoryService(Profile::EXPLICIT_ACCESS);
   term1_url_ = GURL(default_t_url_->url()->ReplaceSearchTerms(
-      *default_t_url_, UTF16ToWide(term1_), 0, std::wstring()));
+      *default_t_url_, term1_, 0, string16()));
   history->AddPageWithDetails(term1_url_, string16(), 1, 1,
                               base::Time::Now(), false,
                               history::SOURCE_BROWSED);
   history->SetKeywordSearchTermsForURL(term1_url_, default_t_url_->id(),
                                        term1_);
 
   // Create another TemplateURL.
   keyword_t_url_ = new TemplateURL();
-  keyword_t_url_->set_keyword(L"k");
+  keyword_t_url_->set_keyword(ASCIIToUTF16("k"));
   keyword_t_url_->SetURL("http://keyword/{searchTerms}", 0, 0);
   keyword_t_url_->SetSuggestionsURL("http://suggest_keyword/{searchTerms}", 0,
                                     0);
   profile_.GetTemplateURLModel()->Add(keyword_t_url_);
   ASSERT_NE(0, keyword_t_url_->id());
 
   // Add a page and search term for keyword_t_url_.
   keyword_url_ = GURL(keyword_t_url_->url()->ReplaceSearchTerms(
-      *keyword_t_url_, UTF16ToWide(keyword_term_), 0, std::wstring()));
+      *keyword_t_url_, keyword_term_, 0, string16()));
   history->AddPageWithDetails(keyword_url_, string16(), 1, 1,
                               base::Time::Now(), false,
                               history::SOURCE_BROWSED);
   history->SetKeywordSearchTermsForURL(keyword_url_, keyword_t_url_->id(),
                                        keyword_term_);
 
   // Keywords are updated by the InMemoryHistoryBackend only after the message
   // has been processed on the history thread. Block until history processes all
   // requests to ensure the InMemoryDatabase is the state we expect it.
   profile_.BlockUntilHistoryProcessesPendingRequests();
@@ skipping 72 matching lines @@
   string16 term = term1_.substr(0, term1_.size() - 1);
   QueryForInput(term, false);
 
   // Make sure the default providers suggest service was queried.
   TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(fetcher);
 
   // And the URL matches what we expected.
   GURL expected_url = GURL(default_t_url_->suggestions_url()->
-      ReplaceSearchTerms(*default_t_url_, UTF16ToWide(term),
-      0, std::wstring()));
+      ReplaceSearchTerms(*default_t_url_, term, 0, string16()));
   ASSERT_TRUE(fetcher->original_url() == expected_url);
 
   // Tell the SearchProvider the suggest query is done.
   fetcher->delegate()->OnURLFetchComplete(
       fetcher, GURL(), URLRequestStatus(), 200, ResponseCookies(),
       std::string());
   fetcher = NULL;
 
   // Run till the history results complete.
   RunTillProviderDone();
 
   // The SearchProvider is done. Make sure it has a result for the history
   // term term1.
   AutocompleteMatch term1_match = FindMatchWithDestination(term1_url_);
   EXPECT_TRUE(!term1_match.destination_url.is_empty());
   // Term1 should have a description.
   EXPECT_FALSE(term1_match.description.empty());
 
   GURL what_you_typed_url = GURL(default_t_url_->url()->ReplaceSearchTerms(
-      *default_t_url_, UTF16ToWide(term), 0, std::wstring()));
+      *default_t_url_, term, 0, string16()));
   AutocompleteMatch what_you_typed_match =
       FindMatchWithDestination(what_you_typed_url);
   EXPECT_TRUE(!what_you_typed_match.destination_url.is_empty());
   EXPECT_TRUE(what_you_typed_match.description.empty());
 
   // The match for term1 should be more relevant than the what you typed result.
   EXPECT_GT(term1_match.relevance, what_you_typed_match.relevance);
 }
 
 TEST_F(SearchProviderTest, HonorPreventInlineAutocomplete) {
   string16 term = term1_.substr(0, term1_.size() - 1);
   QueryForInput(term, true);
 
   ASSERT_FALSE(provider_->matches().empty());
   ASSERT_EQ(AutocompleteMatch::SEARCH_WHAT_YOU_TYPED,
             provider_->matches()[0].type);
 }
 
 // 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_.size() - 1);
-  QueryForInput(WideToUTF16(keyword_t_url_->keyword()) +
+  QueryForInput(keyword_t_url_->keyword() +
                 UTF8ToUTF16(" ") + term, false);
 
   // Make sure the default providers suggest service was queried.
   TestURLFetcher* default_fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(default_fetcher);
 
   // Tell the SearchProvider the default suggest query is done.
   default_fetcher->delegate()->OnURLFetchComplete(
       default_fetcher, GURL(), URLRequestStatus(), 200, ResponseCookies(),
       std::string());
   default_fetcher = NULL;
 
   // Make sure the keyword providers suggest service was queried.
   TestURLFetcher* keyword_fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kKeywordProviderURLFetcherID);
   ASSERT_TRUE(keyword_fetcher);
 
   // And the URL matches what we expected.
   GURL expected_url = GURL(keyword_t_url_->suggestions_url()->
-      ReplaceSearchTerms(*keyword_t_url_, UTF16ToWide(term), 0,
-      std::wstring()));
+      ReplaceSearchTerms(*keyword_t_url_, term, 0, string16()));
   ASSERT_TRUE(keyword_fetcher->original_url() == expected_url);
 
   // Tell the SearchProvider the keyword suggest query is done.
   keyword_fetcher->delegate()->OnURLFetchComplete(
       keyword_fetcher, GURL(), URLRequestStatus(), 200, ResponseCookies(),
       std::string());
   keyword_fetcher = NULL;
 
   // Run till the history results complete.
   RunTillProviderDone();
 
   // The SearchProvider is done. Make sure it has a result for the history
   // term keyword.
   AutocompleteMatch match = FindMatchWithDestination(keyword_url_);
   ASSERT_TRUE(!match.destination_url.is_empty());
 
   // The match should have a TemplateURL.
   EXPECT_TRUE(match.template_url);
 
   // The fill into edit should contain the keyword.
-  EXPECT_EQ(keyword_t_url_->keyword() + L" " + UTF16ToWide(keyword_term_),
+  EXPECT_EQ(UTF16ToWideHack(keyword_t_url_->keyword()) +
+                L" " + UTF16ToWide(keyword_term_),
             match.fill_into_edit);
 }
 
 TEST_F(SearchProviderTest, DontSendPrivateDataToSuggest) {
   // None of the following input strings should be sent to the suggest server,
   // because they may contain private data.
   const char* inputs[] = {
     "username:password",
     "http://username:password",
     "https://username:password",
@@ skipping 35 matching lines @@
   // Tell the provider instant is done.
   provider_->FinalizeInstantQuery(L"foo", L"bar");
 
   // The provider should now be done.
   EXPECT_TRUE(provider_->done());
 
   // There should be two matches, one for what you typed, the other for
   // 'foobar'.
   EXPECT_EQ(2u, provider_->matches().size());
   GURL instant_url = GURL(default_t_url_->url()->ReplaceSearchTerms(
-      *default_t_url_, L"foobar", 0, std::wstring()));
+      *default_t_url_, ASCIIToUTF16("foobar"), 0, string16()));
   AutocompleteMatch instant_match = FindMatchWithDestination(instant_url);
   EXPECT_TRUE(!instant_match.destination_url.is_empty());
 
   // And the 'foobar' match should have a description.
   EXPECT_FALSE(instant_match.description.empty());
 
   // Make sure the what you typed match has no description.
   GURL what_you_typed_url = GURL(default_t_url_->url()->ReplaceSearchTerms(
-      *default_t_url_, L"foo", 0, std::wstring()));
+      *default_t_url_, ASCIIToUTF16("foo"), 0, string16()));
   AutocompleteMatch what_you_typed_match =
       FindMatchWithDestination(what_you_typed_url);
   EXPECT_TRUE(!what_you_typed_match.destination_url.is_empty());
   EXPECT_TRUE(what_you_typed_match.description.empty());
 
   // The instant search should be more relevant.
   EXPECT_GT(instant_match.relevance, what_you_typed_match.relevance);
 }
 
 // Make sure that if FinalizeInstantQuery is invoked before suggest results
 // return, the suggest text from FinalizeInstantQuery is remembered.
 TEST_F(SearchProviderTest, RememberInstantQuery) {
   PrefService* service = profile_.GetPrefs();
   service->SetBoolean(prefs::kInstantEnabled, true);
 
   QueryForInput(ASCIIToUTF16("foo"), false);
 
   // Finalize the instant query immediately.
   provider_->FinalizeInstantQuery(L"foo", L"bar");
 
   // There should be two matches, one for what you typed, the other for
   // 'foobar'.
   EXPECT_EQ(2u, provider_->matches().size());
   GURL instant_url = GURL(default_t_url_->url()->ReplaceSearchTerms(
-      *default_t_url_, L"foobar", 0, std::wstring()));
+      *default_t_url_, ASCIIToUTF16("foobar"), 0, string16()));
   AutocompleteMatch instant_match = FindMatchWithDestination(instant_url);
   EXPECT_FALSE(instant_match.destination_url.is_empty());
 
   // Wait until history and the suggest query complete.
   profile_.BlockUntilHistoryProcessesPendingRequests();
   ASSERT_NO_FATAL_FAILURE(FinishDefaultSuggestQuery());
 
   // Provider should be done.
   EXPECT_TRUE(provider_->done());
 
   // There should be two matches, one for what you typed, the other for
   // 'foobar'.
   EXPECT_EQ(2u, provider_->matches().size());
   instant_match = FindMatchWithDestination(instant_url);
   EXPECT_FALSE(instant_match.destination_url.is_empty());
 
   // And the 'foobar' match should have a description.
   EXPECT_FALSE(instant_match.description.empty());
 }