Remove wstring from autocomplete.

chrome/browser/autocomplete/history_url_provider.cc

 // Copyright (c) 2010 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_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
@@ skipping 60 matching lines @@
   if (a.url_info.visit_count() != b.url_info.visit_count())
     return a.url_info.visit_count() > b.url_info.visit_count();
 
   // URLs that have been visited more recently are better.
   return a.url_info.last_visit() > b.url_info.last_visit();
 }
 
 // Given the user's |input| and a |match| created from it, reduce the
 // match's URL to just a host.  If this host still matches the user input,
 // return it.  Returns the empty string on failure.
-GURL ConvertToHostOnly(const HistoryMatch& match, const std::wstring& input) {
+GURL ConvertToHostOnly(const HistoryMatch& match, const string16& input) {
   // See if we should try to do host-only suggestions for this URL. Nonstandard
   // schemes means there's no authority section, so suggesting the host name
   // is useless. File URLs are standard, but host suggestion is not useful for
   // them either.
   const GURL& url = match.url_info.url();
   if (!url.is_valid() || !url.IsStandard() || url.SchemeIsFile())
     return GURL();
 
   // Transform to a host-only match.  Bail if the host no longer matches the
   // user input (e.g. because the user typed more than just a host).
   GURL host = url.GetWithEmptyPath();
   if ((host.spec().length() < (match.input_location + input.length())))
     return GURL();  // User typing is longer than this host suggestion.
 
-  const std::wstring spec = UTF8ToWide(host.spec());
+  const string16 spec = UTF8ToUTF16(host.spec());
   if (spec.compare(match.input_location, input.length(), input))
     return GURL();  // User typing is no longer a prefix.
 
   return host;
 }
 
 }  // namespace history
 
 HistoryURLProviderParams::HistoryURLProviderParams(
     const AutocompleteInput& input,
@@ skipping 74 matching lines @@
   // * Their input can be opened as a URL, and
   // * They hit ctrl-enter, or we parsed the input as a URL, or it starts with
   //   an explicit "http:" or "https:".
   // Otherwise, this is just low-quality noise.  In the cases where we've parsed
   // as UNKNOWN, we'll still show an accidental search infobar if need be.
   bool have_what_you_typed_match =
       params->input.canonicalized_url().is_valid() &&
       (params->input.type() != AutocompleteInput::QUERY) &&
       ((params->input.type() != AutocompleteInput::UNKNOWN) ||
           !params->trim_http ||
-          url_util::FindAndCompareScheme(WideToUTF8(params->input.text()),
+          url_util::FindAndCompareScheme(UTF16ToUTF8(params->input.text()),
                                          chrome::kHttpsScheme, NULL));
   AutocompleteMatch what_you_typed_match(SuggestExactInput(params->input,
                                                            params->trim_http));
 
   // Get the matching URLs from the DB
   typedef std::vector<history::URLRow> URLRowVector;
   URLRowVector url_matches;
   HistoryMatches history_matches;
 
   for (Prefixes::const_iterator i(prefixes_.begin()); i != prefixes_.end();
        ++i) {
     if (params->cancel)
       return;  // Canceled in the middle of a query, give up.
     // We only need kMaxMatches results in the end, but before we get there we
     // need to promote lower-quality matches that are prefixes of
     // higher-quality matches, and remove lower-quality redirects.  So we ask
     // for more results than we need, of every prefix type, in hopes this will
     // give us far more than enough to work with.  CullRedirects() will then
     // reduce the list to the best kMaxMatches results.
-    db->AutocompleteForPrefix(WideToUTF16(i->prefix + params->input.text()),
+    db->AutocompleteForPrefix(i->prefix + params->input.text(),
                               kMaxMatches * 2, (backend == NULL), &url_matches);
     for (URLRowVector::const_iterator j(url_matches.begin());
          j != url_matches.end(); ++j) {
-      const Prefix* best_prefix = BestPrefix(j->url(), std::wstring());
+      const Prefix* best_prefix = BestPrefix(j->url(), string16());
       DCHECK(best_prefix != NULL);
       history_matches.push_back(HistoryMatch(*j, i->prefix.length(),
           !i->num_components,
           i->num_components >= best_prefix->num_components));
     }
   }
 
   // Create sorted list of suggestions.
   CullPoorMatches(&history_matches);
   SortMatches(&history_matches);
@@ skipping 80 matching lines @@
   const GURL& url = input.canonicalized_url();
   if (url.is_valid()) {
     match.destination_url = url;
 
     // Trim off "http://" if the user didn't type it.
     // NOTE: We use TrimHttpPrefix() here rather than StringForURLDisplay() to
     // strip the scheme as we need to know the offset so we can adjust the
     // |match_location| below.  StringForURLDisplay() and TrimHttpPrefix() have
     // slightly different behavior as well (the latter will strip even without
     // two slashes after the scheme).
-    std::wstring display_string(StringForURLDisplay(url, false, false));
+    string16 display_string(StringForURLDisplay(url, false, false));
     const size_t offset = trim_http ? TrimHttpPrefix(&display_string) : 0;
     match.fill_into_edit =
         AutocompleteInput::FormattedStringWithEquivalentMeaning(url,
                                                                 display_string);
     // NOTE: Don't set match.input_location (to allow inline autocompletion)
     // here, it's surprising and annoying.
 
     // Try to highlight "innermost" match location.  If we fix up "w" into
     // "www.w.com", we want to highlight the fifth character, not the first.
     // This relies on match.destination_url being the non-prefix-trimmed version
     // of match.contents.
     match.contents = display_string;
     const Prefix* best_prefix = BestPrefix(match.destination_url, input.text());
     // Because of the vagaries of GURL, it's possible for match.destination_url
     // to not contain the user's input at all.  In this case don't mark anything
     // as a match.
     const size_t match_location = (best_prefix == NULL) ?
-        std::wstring::npos : best_prefix->prefix.length() - offset;
+        string16::npos : best_prefix->prefix.length() - offset;
     AutocompleteMatch::ClassifyLocationInString(match_location,
                                                 input.text().length(),
                                                 match.contents.length(),
                                                 ACMatchClassification::URL,
                                                 &match.contents_class);
 
     match.is_history_what_you_typed_match = true;
   }
 
   return match;
@@ skipping 19 matching lines @@
   // * If the what-you-typed match is not in the history DB,
   // * and the user has specified a TLD,
   // * and the input _without_ the TLD _is_ in the history DB,
   // * ...then just before pressing "ctrl" the best match we supplied was the
   //   what-you-typed match, so stick with it by promoting this.
   history::URLRow info;
   MatchType type = INLINE_AUTOCOMPLETE;
   if (!db->GetRowForURL(match->destination_url, &info)) {
     if (input.desired_tld().empty())
       return false;
-    GURL destination_url(URLFixerUpper::FixupURL(WideToUTF8(input.text()),
+    GURL destination_url(URLFixerUpper::FixupURL(UTF16ToUTF8(input.text()),
                                                  std::string()));
     if (!db->GetRowForURL(destination_url, NULL))
       return false;
 
     // If we got here, then we hit the tricky corner case.  Make sure that
     // |info| corresponds to the right URL.
     info = history::URLRow(match->destination_url);
   } else {
     // We have data for this match, use it.
     match->deletable = true;
-    match->description = UTF16ToWide(info.title());
+    match->description = info.title();
     AutocompleteMatch::ClassifyMatchInString(input.text(),
-        UTF16ToWide(info.title()),
+        info.title(),
         ACMatchClassification::NONE, &match->description_class);
     if (!info.typed_count()) {
       // If we reach here, we must be in the second pass, and we must not have
       // promoted this match as an exact match during the first pass.  That
       // means it will have been outscored by the "search what you typed match".
       // We need to maintain that ordering in order to not make the destination
       // for the user's typing change depending on when they hit enter.  So
       // lower the score here enough to let the search provider continue to
       // outscore this match.
       type = WHAT_YOU_TYPED;
     }
   }
 
   // Promote as an exact match.
   match->relevance = CalculateRelevance(input.type(), type, 0);
 
   // Put it on the front of the HistoryMatches for redirect culling.
-  EnsureMatchPresent(info, std::wstring::npos, false, matches, true);
+  EnsureMatchPresent(info, string16::npos, false, matches, true);
   return true;
 }
 
 bool HistoryURLProvider::PromoteMatchForInlineAutocomplete(
     HistoryURLProviderParams* params,
     const HistoryMatch& match) {
   // Promote the first match if it's been typed at least n times, where n == 1
   // for "simple" (host-only) URLs and n == 2 for others.  We set a higher bar
   // for these long URLs because it's less likely that users will want to visit
   // them again.  Even though we don't increment the typed_count for pasted-in
   // URLs, if the user manually edits the URL or types some long thing in by
   // hand, we wouldn't want to immediately start autocompleting it.
   if (!match.url_info.typed_count() ||
       ((match.url_info.typed_count() == 1) &&
        !history::IsHostOnly(match.url_info.url())))
     return false;
 
   params->matches.push_back(HistoryMatchToACMatch(params, match,
                                                   INLINE_AUTOCOMPLETE, 0));
   return true;
 }
 
 // static
 history::Prefixes HistoryURLProvider::GetPrefixes() {
   // We'll complete text following these prefixes.
   // NOTE: There's no requirement that these be in any particular order.
   Prefixes prefixes;
-  prefixes.push_back(Prefix(L"https://www.", 2));
-  prefixes.push_back(Prefix(L"http://www.", 2));
-  prefixes.push_back(Prefix(L"ftp://ftp.", 2));
-  prefixes.push_back(Prefix(L"ftp://www.", 2));
-  prefixes.push_back(Prefix(L"https://", 1));
-  prefixes.push_back(Prefix(L"http://", 1));
-  prefixes.push_back(Prefix(L"ftp://", 1));
-  prefixes.push_back(Prefix(L"", 0));  // Catches within-scheme matches as well
+  prefixes.push_back(Prefix(ASCIIToUTF16("https://www."), 2));
+  prefixes.push_back(Prefix(ASCIIToUTF16("http://www."), 2));
+  prefixes.push_back(Prefix(ASCIIToUTF16("ftp://ftp."), 2));
+  prefixes.push_back(Prefix(ASCIIToUTF16("ftp://www."), 2));
+  prefixes.push_back(Prefix(ASCIIToUTF16("https://"), 1));
+  prefixes.push_back(Prefix(ASCIIToUTF16("http://"), 1));
+  prefixes.push_back(Prefix(ASCIIToUTF16("ftp://"), 1));
+  // Empty string catches within-scheme matches as well.
+  prefixes.push_back(Prefix(string16(), 0));
   return prefixes;
 }
 
 // static
 int HistoryURLProvider::CalculateRelevance(AutocompleteInput::Type input_type,
                                            MatchType match_type,
                                            size_t match_number) {
   switch (match_type) {
     case INLINE_AUTOCOMPLETE:
       return 1400;
@@ skipping 71 matching lines @@
   }
 
   // Promote or add the desired URL to the list of matches.
   EnsureMatchPresent(info, match.input_location, match.match_in_scheme,
                      matches, promote);
 }
 
 // static
 void HistoryURLProvider::EnsureMatchPresent(
     const history::URLRow& info,
-    std::wstring::size_type input_location,
+    string16::size_type input_location,
     bool match_in_scheme,
     HistoryMatches* matches,
     bool promote) {
   // |matches| may already have an entry for this.
   for (HistoryMatches::iterator i(matches->begin()); i != matches->end();
        ++i) {
     if (i->url_info.url() == info.url()) {
       // Rotate it to the front if the caller wishes.
       if (promote)
         std::rotate(matches->begin(), i, i + 1);
@@ skipping 44 matching lines @@
   }
   scoped_ptr<HistoryURLProviderParams> params(
       new HistoryURLProviderParams(input, trim_http, languages));
 
   if (fixup_input_and_run_pass_1) {
     // Do some fixup on the user input before matching against it, so we provide
     // good results for local file paths, input with spaces, etc.
     // NOTE: This purposefully doesn't take input.desired_tld() into account; if
     // it did, then holding "ctrl" would change all the results from the
     // HistoryURLProvider provider, not just the What You Typed Result.
-    const std::wstring fixed_text(FixupUserInput(input));
+    const string16 fixed_text(FixupUserInput(input));
     if (fixed_text.empty()) {
       // Conceivably fixup could result in an empty string (although I don't
       // have cases where this happens offhand).  We can't do anything with
       // empty input, so just bail; otherwise we'd crash later.
       return;
     }
     params->input.set_text(fixed_text);
 
     // Pass 1: Get the in-memory URL database, and use it to find and promote
     // the inline autocomplete match, if any.
@@ skipping 20 matching lines @@
   if (!input.synchronous_only()) {
     done_ = false;
     params_ = params.release();  // This object will be destroyed in
                                  // QueryComplete() once we're done with it.
     history_service->ScheduleAutocomplete(this, params_);
   }
 }
 
 const history::Prefix* HistoryURLProvider::BestPrefix(
     const GURL& url,
-    const std::wstring& prefix_suffix) const {
+    const string16& prefix_suffix) const {
   const Prefix* best_prefix = NULL;
-  const std::wstring text(UTF8ToWide(url.spec()));
+  const string16 text(UTF8ToUTF16(url.spec()));
   for (Prefixes::const_iterator i(prefixes_.begin()); i != prefixes_.end();
        ++i) {
     if ((best_prefix == NULL) ||
         (i->num_components > best_prefix->num_components)) {
-      std::wstring prefix_with_suffix(i->prefix + prefix_suffix);
+      string16 prefix_with_suffix(i->prefix + prefix_suffix);
       if ((text.length() >= prefix_with_suffix.length()) &&
           !text.compare(0, prefix_with_suffix.length(), prefix_with_suffix))
         best_prefix = &(*i);
     }
   }
   return best_prefix;
 }
 
 void HistoryURLProvider::SortMatches(HistoryMatches* matches) const {
   // Sort by quality, best first.
@@ skipping 115 matching lines @@
   DCHECK(match.destination_url.is_valid());
   size_t inline_autocomplete_offset =
       history_match.input_location + params->input.text().length();
   std::string languages = (match_type == WHAT_YOU_TYPED) ?
       std::string() : params->languages;
   const net::FormatUrlTypes format_types = net::kFormatUrlOmitAll &
       ~((params->trim_http && !history_match.match_in_scheme) ?
           0 : net::kFormatUrlOmitHTTP);
   match.fill_into_edit =
       AutocompleteInput::FormattedStringWithEquivalentMeaning(info.url(),
-          UTF16ToWideHack(net::FormatUrl(info.url(), languages, format_types,
-                                         UnescapeRule::SPACES, NULL, NULL,
-                                         &inline_autocomplete_offset)));
+          net::FormatUrl(info.url(), languages, format_types,
+                         UnescapeRule::SPACES, NULL, NULL,
+                         &inline_autocomplete_offset));
   if (!params->input.prevent_inline_autocomplete())
     match.inline_autocomplete_offset = inline_autocomplete_offset;
-  DCHECK((match.inline_autocomplete_offset == std::wstring::npos) ||
+  DCHECK((match.inline_autocomplete_offset == string16::npos) ||
          (match.inline_autocomplete_offset <= match.fill_into_edit.length()));
 
   size_t match_start = history_match.input_location;
-  match.contents = UTF16ToWideHack(net::FormatUrl(info.url(), languages,
-      format_types, UnescapeRule::SPACES, NULL, NULL, &match_start));
-  if ((match_start != std::wstring::npos) &&
-      (inline_autocomplete_offset != std::wstring::npos) &&
+  match.contents = net::FormatUrl(info.url(), languages,
+      format_types, UnescapeRule::SPACES, NULL, NULL, &match_start);
+  if ((match_start != string16::npos) &&
+      (inline_autocomplete_offset != string16::npos) &&
       (inline_autocomplete_offset != match_start)) {
     DCHECK(inline_autocomplete_offset > match_start);
     AutocompleteMatch::ClassifyLocationInString(match_start,
         inline_autocomplete_offset - match_start, match.contents.length(),
         ACMatchClassification::URL, &match.contents_class);
   } else {
-    AutocompleteMatch::ClassifyLocationInString(std::wstring::npos, 0,
+    AutocompleteMatch::ClassifyLocationInString(string16::npos, 0,
         match.contents.length(), ACMatchClassification::URL,
         &match.contents_class);
   }
-  match.description = UTF16ToWide(info.title());
+  match.description = info.title();
   AutocompleteMatch::ClassifyMatchInString(params->input.text(),
-                                           UTF16ToWide(info.title()),
+                                           info.title(),
                                            ACMatchClassification::NONE,
                                            &match.description_class);
 
   return match;
 }