Revert 72380 - Remove wstring from autocomplete....

chrome/browser/autocomplete/search_provider.cc

 // 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 "chrome/browser/autocomplete/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 45 matching lines @@
     cached_keyword_provider_ = *keyword_provider;
 }
 
 SearchProvider::SearchProvider(ACProviderListener* listener, Profile* profile)
     : AutocompleteProvider(listener, profile, "Search"),
       suggest_results_pending_(0),
       have_suggest_results_(false),
       instant_finalized_(false) {
 }
 
-void SearchProvider::FinalizeInstantQuery(const string16& input_text,
-                                          const string16& suggest_text) {
+void SearchProvider::FinalizeInstantQuery(const std::wstring& input_text,
+                                          const std::wstring& suggest_text) {
   if (done_ || instant_finalized_)
     return;
 
   instant_finalized_ = true;
   UpdateDone();
 
   if (input_text.empty()) {
     // We only need to update the listener if we're actually done.
     if (done_)
       listener_->OnProviderUpdate(false);
     return;
   }
 
   default_provider_suggest_text_ = suggest_text;
 
-  string16 adjusted_input_text(input_text);
+  std::wstring adjusted_input_text(input_text);
   AutocompleteInput::RemoveForcedQueryStringIfNecessary(input_.type(),
                                                         &adjusted_input_text);
 
-  const string16 text = adjusted_input_text + suggest_text;
+  const std::wstring text = adjusted_input_text + suggest_text;
   // Remove any matches that are identical to |text|. We don't use the
   // destination_url for comparison as it varies depending upon the index passed
   // to TemplateURL::ReplaceSearchTerms.
   for (ACMatches::iterator i = matches_.begin(); i != matches_.end();) {
     // Reset the description/description_class of all searches. We'll set the
     // description of the new first match in the call to
     // UpdateFirstSearchMatchDescription() below.
     if ((i->type == AutocompleteMatch::SEARCH_HISTORY) ||
         (i->type == AutocompleteMatch::SEARCH_SUGGEST) ||
         (i->type == AutocompleteMatch::SEARCH_WHAT_YOU_TYPED)) {
@@ skipping 75 matching lines @@
   }
 
   providers_.Set(default_provider, keyword_provider);
 
   if (input.text().empty()) {
     // User typed "?" alone.  Give them a placeholder result indicating what
     // this syntax does.
     if (default_provider) {
       AutocompleteMatch match;
       match.provider = this;
-      match.contents.assign(l10n_util::GetStringUTF16(IDS_EMPTY_KEYWORD_VALUE));
+      match.contents.assign(UTF16ToWideHack(
+          l10n_util::GetStringUTF16(IDS_EMPTY_KEYWORD_VALUE)));
       match.contents_class.push_back(
           ACMatchClassification(0, ACMatchClassification::NONE));
       matches_.push_back(match);
       UpdateFirstSearchMatchDescription();
     }
     Stop();
     return;
   }
 
   input_ = input;
@@ skipping 42 matching lines @@
   DCHECK_GE(suggest_results_pending_, 0);  // Should never go negative.
   const net::HttpResponseHeaders* const response_headers =
       source->response_headers();
   std::string json_data(data);
   // JSON is supposed to be UTF-8, but some suggest service providers send JSON
   // files in non-UTF-8 encodings.  The actual encoding is usually specified in
   // the Content-Type header field.
   if (response_headers) {
     std::string charset;
     if (response_headers->GetCharset(&charset)) {
-      string16 data_16;
+      std::wstring wide_data;
       // TODO(jungshik): Switch to CodePageToUTF8 after it's added.
-      if (base::CodepageToUTF16(data, charset.c_str(),
-                                base::OnStringConversionError::FAIL,
-                                &data_16))
-        json_data = UTF16ToUTF8(data_16);
+      if (base::CodepageToWide(data, charset.c_str(),
+                               base::OnStringConversionError::FAIL,
+                               &wide_data))
+        json_data = WideToUTF8(wide_data);
     }
   }
 
   bool is_keyword_results = (source == keyword_fetcher_.get());
   SuggestResults* suggest_results = is_keyword_results ?
       &keyword_suggest_results_ : &default_suggest_results_;
 
   if (status.is_success() && response_code == 200) {
     JSONStringValueSerializer deserializer(json_data);
     deserializer.set_allow_trailing_comma(true);
     scoped_ptr<Value> root_val(deserializer.Deserialize(NULL, NULL));
-    const string16& input_text =
+    const std::wstring& input_text =
         is_keyword_results ? keyword_input_text_ : input_.text();
     have_suggest_results_ =
         root_val.get() &&
         ParseSuggestResults(root_val.get(), is_keyword_results, input_text,
                             suggest_results);
   }
 
   ConvertResultsToAutocompleteMatches();
   listener_->OnProviderUpdate(!suggest_results->empty());
 }
@@ skipping 14 matching lines @@
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   history::URLDatabase* url_db = history_service ?
       history_service->InMemoryDatabase() : NULL;
   if (!url_db)
     return;
 
   // Request history for both the keyword and default provider.
   if (providers_.valid_keyword_provider()) {
     url_db->GetMostRecentKeywordSearchTerms(
         providers_.keyword_provider().id(),
-        keyword_input_text_,
+        WideToUTF16(keyword_input_text_),
         static_cast<int>(kMaxMatches),
         &keyword_history_results_);
   }
   if (providers_.valid_default_provider()) {
     url_db->GetMostRecentKeywordSearchTerms(
         providers_.default_provider().id(),
-        input_.text(),
+        WideToUTF16(input_.text()),
         static_cast<int>(kMaxMatches),
         &default_history_results_);
   }
 }
 
 void SearchProvider::StartOrStopSuggestQuery(bool minimal_changes) {
   // Don't send any queries to the server until some time has elapsed after
   // the last keypress, to avoid flooding the server with requests we are
   // likely to end up throwing away anyway.
   static const int kQueryDelayMs = 200;
@@ skipping 49 matching lines @@
   // Next we check the scheme.  If this is UNKNOWN/REQUESTED_URL/URL with a
   // scheme that isn't http/https/ftp, we shouldn't send it.  Sending things
   // like file: and data: is both a waste of time and a disclosure of
   // potentially private, local data.  Other "schemes" may actually be
   // usernames, and we don't want to send passwords.  If the scheme is OK, we
   // still need to check other cases below.  If this is QUERY, then the presence
   // of these schemes means the user explicitly typed one, and thus this is
   // probably a URL that's being entered and happens to currently be invalid --
   // in which case we again want to run our checks below.  Other QUERY cases are
   // less likely to be URLs and thus we assume we're OK.
-  if (!LowerCaseEqualsASCII(input_.scheme(), chrome::kHttpScheme) &&
-      !LowerCaseEqualsASCII(input_.scheme(), chrome::kHttpsScheme) &&
-      !LowerCaseEqualsASCII(input_.scheme(), chrome::kFtpScheme))
+  if ((input_.scheme() != L"http") && (input_.scheme() != L"https") &&
+      (input_.scheme() != L"ftp"))
     return (input_.type() == AutocompleteInput::QUERY);
 
   // Don't send URLs with usernames, queries or refs.  Some of these are
   // private, and the Suggest server is unlikely to have any useful results
   // for any of them.  Also don't send URLs with ports, as we may initially
   // think that a username + password is a host + port (and we don't want to
   // send usernames/passwords), and even if the port really is a port, the
   // server is once again unlikely to have and useful results.
   const url_parse::Parsed& parts = input_.parts();
   if (parts.username.is_nonempty() || parts.port.is_nonempty() ||
       parts.query.is_nonempty() || parts.ref.is_nonempty())
     return false;
 
   // Don't send anything for https except the hostname.  Hostnames are OK
   // because they are visible when the TCP connection is established, but the
   // specific path may reveal private information.
-  if (LowerCaseEqualsASCII(input_.scheme(), chrome::kHttpsScheme) &&
-      parts.path.is_nonempty())
+  if ((input_.scheme() == L"https") && parts.path.is_nonempty())
     return false;
 
   return true;
 }
 
 void SearchProvider::StopSuggest() {
   suggest_results_pending_ = 0;
   timer_.Stop();
   // Stop any in-progress URL fetches.
   keyword_fetcher_.reset();
   default_fetcher_.reset();
   keyword_suggest_results_.clear();
   default_suggest_results_.clear();
   keyword_navigation_results_.clear();
   default_navigation_results_.clear();
   have_suggest_results_ = false;
 }
 
 URLFetcher* SearchProvider::CreateSuggestFetcher(int id,
                                                  const TemplateURL& provider,
-                                                 const string16& text) {
+                                                 const std::wstring& text) {
   const TemplateURLRef* const suggestions_url = provider.suggestions_url();
   DCHECK(suggestions_url->SupportsReplacement());
   URLFetcher* fetcher = URLFetcher::Create(id,
       GURL(suggestions_url->ReplaceSearchTerms(
-           provider, text,
+           provider, WideToUTF16Hack(text),
            TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16())),
       URLFetcher::GET, this);
   fetcher->set_request_context(profile_->GetRequestContext());
   fetcher->Start();
   return fetcher;
 }
 
 bool SearchProvider::ParseSuggestResults(Value* root_val,
                                          bool is_keyword,
-                                         const string16& input_text,
+                                         const std::wstring& input_text,
                                          SuggestResults* suggest_results) {
   if (!root_val->IsType(Value::TYPE_LIST))
     return false;
   ListValue* root_list = static_cast<ListValue*>(root_val);
 
   Value* query_val;
   string16 query_str;
   Value* result_val;
   if ((root_list->GetSize() < 2) || !root_list->Get(0, &query_val) ||
       !query_val->GetAsString(&query_str) ||
-      (query_str != input_text) ||
+      (query_str != WideToUTF16Hack(input_text)) ||
       !root_list->Get(1, &result_val) || !result_val->IsType(Value::TYPE_LIST))
     return false;
 
   ListValue* description_list = NULL;
   if (root_list->GetSize() > 2) {
     // 3rd element: Description list.
     Value* description_val;
     if (root_list->Get(2, &description_val) &&
         description_val->IsType(Value::TYPE_LIST))
       description_list = static_cast<ListValue*>(description_val);
@@ skipping 44 matching lines @@
           is_keyword ? keyword_navigation_results_ :
                        default_navigation_results_;
       if ((navigation_results.size() < kMaxMatches) &&
           description_list && description_list->Get(i, &site_val) &&
           site_val->IsType(Value::TYPE_STRING) &&
           site_val->GetAsString(&site_name)) {
         // We can't blindly trust the URL coming from the server to be valid.
         GURL result_url(URLFixerUpper::FixupURL(UTF16ToUTF8(suggestion_str),
                                                 std::string()));
         if (result_url.is_valid()) {
-          navigation_results.push_back(NavigationResult(result_url, site_name));
+          navigation_results.push_back(NavigationResult(result_url,
+              UTF16ToWideHack(site_name)));
         }
       }
     } else {
       // TODO(kochi): Currently we treat a calculator result as a query, but it
       // is better to have better presentation for caluculator results.
       if (suggest_results->size() < kMaxMatches)
-        suggest_results->push_back(suggestion_str);
+        suggest_results->push_back(UTF16ToWideHack(suggestion_str));
     }
   }
 
   return true;
 }
 
 void SearchProvider::ConvertResultsToAutocompleteMatches() {
   // Convert all the results to matches and add them to a map, so we can keep
   // the most relevant match for each result.
   MatchMap map;
@@ skipping 80 matching lines @@
     // match having a relevance greater than the previous, but they might be
     // equal. If we didn't force the relevance to decrease and we ended up in a
     // situation where the relevance was equal, then which was shown first would
     // be random.
     // This uses >= to handle the case where 3 or more results have the same
     // relevance.
     int relevance = CalculateRelevanceForHistory(i->time, is_keyword);
     if (i != results.begin() && relevance >= last_relevance)
       relevance = last_relevance - 1;
     last_relevance = relevance;
-    AddMatchToMap(i->term,
+    AddMatchToMap(UTF16ToWide(i->term),
                   is_keyword ? keyword_input_text_ : input_.text(),
                   relevance,
                   AutocompleteMatch::SEARCH_HISTORY, did_not_accept_suggestion,
                   is_keyword, input_.initial_prevent_inline_autocomplete(),
                   map);
   }
 }
 
 void SearchProvider::AddSuggestResultsToMap(
     const SuggestResults& suggest_results,
@@ skipping 84 matching lines @@
 int SearchProvider::CalculateRelevanceForNavigation(size_t num_results,
                                                     size_t result_number,
                                                     bool is_keyword) const {
   DCHECK(result_number < num_results);
   // TODO(kochi): http://b/784900  Use relevance score from the NavSuggest
   // server if possible.
   return (providers_.is_primary_provider(is_keyword) ? 800 : 150) +
       static_cast<int>(num_results - 1 - result_number);
 }
 
-void SearchProvider::AddMatchToMap(const string16& query_string,
-                                   const string16& input_text,
+void SearchProvider::AddMatchToMap(const std::wstring& query_string,
+                                   const std::wstring& input_text,
                                    int relevance,
                                    AutocompleteMatch::Type type,
                                    int accepted_suggestion,
                                    bool is_keyword,
                                    bool prevent_inline_autocomplete,
                                    MatchMap* map) {
   AutocompleteMatch match(this, relevance, false, type);
   std::vector<size_t> content_param_offsets;
   const TemplateURL& provider = is_keyword ? providers_.keyword_provider() :
                                              providers_.default_provider();
   match.contents.assign(query_string);
   // We do intra-string highlighting for suggestions - the suggested segment
   // will be highlighted, e.g. for input_text = "you" the suggestion may be
   // "youtube", so we'll bold the "tube" section: you*tube*.
   if (input_text != query_string) {
     size_t input_position = match.contents.find(input_text);
-    if (input_position == string16::npos) {
+    if (input_position == std::wstring::npos) {
       // The input text is not a substring of the query string, e.g. input
       // text is "slasdot" and the query string is "slashdot", so we bold the
       // whole thing.
       match.contents_class.push_back(
           ACMatchClassification(0, ACMatchClassification::MATCH));
     } else {
       // TODO(beng): ACMatchClassification::MATCH now seems to just mean
       //             "bold" this. Consider modifying the terminology.
       // We don't iterate over the string here annotating all matches because
       // it looks odd to have every occurrence of a substring that may be as
@@ skipping 18 matching lines @@
     // completion.
     match.contents_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
   }
 
   // When the user forced a query, we need to make sure all the fill_into_edit
   // values preserve that property.  Otherwise, if the user starts editing a
   // suggestion, non-Search results will suddenly appear.
   size_t search_start = 0;
   if (input_.type() == AutocompleteInput::FORCED_QUERY) {
-    match.fill_into_edit.assign(ASCIIToUTF16("?"));
+    match.fill_into_edit.assign(L"?");
     ++search_start;
   }
   if (is_keyword) {
-    match.fill_into_edit.append(
-        providers_.keyword_provider().keyword() + char16(' '));
+    match.fill_into_edit.append(UTF16ToWideHack(
+        providers_.keyword_provider().keyword() + char16(' ')));
     match.template_url = &providers_.keyword_provider();
   }
   match.fill_into_edit.append(query_string);
   // Not all suggestions start with the original input.
   if (!prevent_inline_autocomplete &&
       !match.fill_into_edit.compare(search_start, input_text.length(),
                                    input_text))
     match.inline_autocomplete_offset = search_start + input_text.length();
 
   const TemplateURLRef* const search_url = provider.url();
   DCHECK(search_url->SupportsReplacement());
   match.destination_url =
       GURL(search_url->ReplaceSearchTerms(provider,
-                                          query_string,
+                                          WideToUTF16Hack(query_string),
                                           accepted_suggestion,
-                                          input_text));
+                                          WideToUTF16Hack(input_text)));
 
   // Search results don't look like URLs.
   match.transition =
       is_keyword ? PageTransition::KEYWORD : PageTransition::GENERATED;
 
   // Try to add |match| to |map|.  If a match for |query_string| is already in
   // |map|, replace it if |match| is more relevant.
   // NOTE: Keep this ToLower() call in sync with url_database.cc.
   const std::pair<MatchMap::iterator, bool> i = map->insert(
-      std::pair<string16, AutocompleteMatch>(
-          l10n_util::ToLower(query_string), match));
+      std::pair<std::wstring, AutocompleteMatch>(
+      UTF16ToWide(l10n_util::ToLower(WideToUTF16(query_string))), match));
   // NOTE: We purposefully do a direct relevance comparison here instead of
   // using AutocompleteMatch::MoreRelevant(), so that we'll prefer "items added
   // first" rather than "items alphabetically first" when the scores are equal.
   // The only case this matters is when a user has results with the same score
   // that differ only by capitalization; because the history system returns
   // results sorted by recency, this means we'll pick the most recent such
   // result even if the precision of our relevance score is too low to
   // distinguish the two.
   if (!i.second && (match.relevance > i.first->second.relevance))
     i.first->second = match;
 }
 
 AutocompleteMatch SearchProvider::NavigationToMatch(
     const NavigationResult& navigation,
     int relevance,
     bool is_keyword) {
-  const string16& input_text =
+  const std::wstring& input_text =
       is_keyword ? keyword_input_text_ : input_.text();
   AutocompleteMatch match(this, relevance, false,
                           AutocompleteMatch::NAVSUGGEST);
   match.destination_url = navigation.url;
   match.contents =
       StringForURLDisplay(navigation.url, true, !HasHTTPScheme(input_text));
   AutocompleteMatch::ClassifyMatchInString(input_text, match.contents,
                                            ACMatchClassification::URL,
                                            &match.contents_class);
 
   match.description = navigation.site_name;
   AutocompleteMatch::ClassifyMatchInString(input_text, navigation.site_name,
                                            ACMatchClassification::NONE,
                                            &match.description_class);
 
   // When the user forced a query, we need to make sure all the fill_into_edit
   // values preserve that property.  Otherwise, if the user starts editing a
   // suggestion, non-Search results will suddenly appear.
   if (input_.type() == AutocompleteInput::FORCED_QUERY)
-    match.fill_into_edit.assign(ASCIIToUTF16("?"));
+    match.fill_into_edit.assign(L"?");
   match.fill_into_edit.append(
       AutocompleteInput::FormattedStringWithEquivalentMeaning(navigation.url,
                                                               match.contents));
   // TODO(pkasting): http://b/1112879 These should perhaps be
   // inline-autocompletable?
 
   return match;
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when there are no more suggest queries pending (this is set to 1
   // when the timer is started) and we're not waiting on instant.
   done_ = ((suggest_results_pending_ == 0) &&
            (instant_finalized_ || !InstantController::IsEnabled(profile_)));
 }
 
 void SearchProvider::UpdateFirstSearchMatchDescription() {
   if (!providers_.valid_default_provider() || matches_.empty())
     return;
 
   for (ACMatches::iterator i = matches_.begin(); i != matches_.end(); ++i) {
     AutocompleteMatch& match = *i;
     switch (match.type) {
       case AutocompleteMatch::SEARCH_WHAT_YOU_TYPED:
       case AutocompleteMatch::SEARCH_HISTORY:
       case AutocompleteMatch::SEARCH_SUGGEST:
-        match.description.assign(l10n_util::GetStringFUTF16(
-            IDS_AUTOCOMPLETE_SEARCH_DESCRIPTION,
-            providers_.default_provider().
-                AdjustedShortNameForLocaleDirection()));
+        match.description.assign(
+            UTF16ToWideHack(l10n_util::GetStringFUTF16(
+                IDS_AUTOCOMPLETE_SEARCH_DESCRIPTION,
+                providers_.default_provider().
+                    AdjustedShortNameForLocaleDirection())));
         match.description_class.push_back(
             ACMatchClassification(0, ACMatchClassification::DIM));
         // Only the first search match gets a description.
         return;
 
       default:
         break;
     }
   }
 }