Remove wstring from TemplateURL and friends....

chrome/browser/autocomplete/keyword_provider.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 "chrome/browser/autocomplete/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "base/string16.h"
@@ skipping 72 matching lines @@
 // Helper functor for Start(), for sorting keyword matches by quality.
 class CompareQuality {
  public:
   // A keyword is of higher quality when a greater fraction of it has been
   // typed, that is, when it is shorter.
   //
   // TODO(pkasting): http://b/740691 Most recent and most frequent keywords are
   // probably better rankings than the fraction of the keyword typed.  We should
   // always put any exact matches first no matter what, since the code in
   // Start() assumes this (and it makes sense).
-  bool operator()(const std::wstring& keyword1,
-                  const std::wstring& keyword2) const {
+  bool operator()(const string16& keyword1,
+                  const string16& keyword2) const {
     return keyword1.length() < keyword2.length();
   }
 };
 
 // We need our input IDs to be unique across all profiles, so we keep a global
 // UID that each provider uses.
 static int global_input_uid_;
 
 }  // namespace
 
 // static
 const TemplateURL* KeywordProvider::GetSubstitutingTemplateURLForInput(
     Profile* profile,
     const AutocompleteInput& input,
     std::wstring* remaining_input) {
   if (!input.allow_exact_keyword_match())
     return NULL;
 
   std::wstring keyword;
   if (!ExtractKeywordFromInput(input, &keyword, remaining_input))
     return NULL;
 
   // Make sure the model is loaded. This is cheap and quickly bails out if
   // the model is already loaded.
   TemplateURLModel* model = profile->GetTemplateURLModel();
   DCHECK(model);
   model->Load();
 
-  const TemplateURL* template_url = model->GetTemplateURLForKeyword(keyword);
+  const TemplateURL* template_url =
+      model->GetTemplateURLForKeyword(WideToUTF16Hack(keyword));
   return TemplateURL::SupportsReplacement(template_url) ? template_url : NULL;
 }
 
 void KeywordProvider::Start(const AutocompleteInput& input,
                             bool minimal_changes) {
   // This object ensures we end keyword mode if we exit the function without
   // toggling keyword mode to on.
   ScopedEndExtensionKeywordMode keyword_mode_toggle(this);
 
   matches_.clear();
@@ skipping 32 matching lines @@
   // Get the best matches for this keyword.
   //
   // NOTE: We could cache the previous keywords and reuse them here in the
   // |minimal_changes| case, but since we'd still have to recalculate their
   // relevances and we can just recreate the results synchronously anyway, we
   // don't bother.
   //
   // TODO(pkasting): http://b/893701 We should remember the user's use of a
   // search query both from the autocomplete popup and from web pages
   // themselves.
-  std::vector<std::wstring> keyword_matches;
-  model->FindMatchingKeywords(keyword, !remaining_input.empty(),
+  std::vector<string16> keyword_matches;
+  model->FindMatchingKeywords(WideToUTF16Hack(keyword),
+                              !remaining_input.empty(),
                               &keyword_matches);
 
   // Prune any extension keywords that are disallowed in incognito mode (if
   // we're incognito), or disabled.
-  for (std::vector<std::wstring>::iterator i(keyword_matches.begin());
+  for (std::vector<string16>::iterator i(keyword_matches.begin());
        i != keyword_matches.end(); ) {
     const TemplateURL* template_url(model->GetTemplateURLForKeyword(*i));
     if (profile_ &&
         !input.synchronous_only() && template_url->IsExtensionKeyword()) {
       ExtensionService* service = profile_->GetExtensionService();
       const Extension* extension = service->GetExtensionById(
           template_url->GetExtensionId(), false);
       bool enabled = extension && (!profile_->IsOffTheRecord() ||
                                    service->IsIncognitoEnabled(extension));
       if (!enabled) {
         i = keyword_matches.erase(i);
         continue;
       }
     }
     ++i;
   }
   if (keyword_matches.empty())
     return;
   std::sort(keyword_matches.begin(), keyword_matches.end(), CompareQuality());
 
   // Limit to one exact or three inexact matches, and mark them up for display
   // in the autocomplete popup.
   // Any exact match is going to be the highest quality match, and thus at the
   // front of our vector.
-  if (keyword_matches.front() == keyword) {
-    const TemplateURL* template_url(model->GetTemplateURLForKeyword(keyword));
+  if (keyword_matches.front() == WideToUTF16Hack(keyword)) {
+    const TemplateURL* template_url(
+        model->GetTemplateURLForKeyword(WideToUTF16Hack(keyword)));
     // TODO(pkasting): We should probably check that if the user explicitly
     // typed a scheme, that scheme matches the one in |template_url|.
     matches_.push_back(CreateAutocompleteMatch(model, keyword, input,
                                                keyword.length(),
                                                remaining_input, -1));
 
     if (profile_ &&
         !input.synchronous_only() && template_url->IsExtensionKeyword()) {
       if (template_url->GetExtensionId() != current_keyword_extension_id_)
         MaybeEndExtensionKeywordMode();
@@ skipping 25 matching lines @@
         // extensions listening for input changes.
         if (have_listeners)
           done_ = false;
       }
     }
   } else {
     if (keyword_matches.size() > kMaxMatches) {
       keyword_matches.erase(keyword_matches.begin() + kMaxMatches,
                             keyword_matches.end());
     }
-    for (std::vector<std::wstring>::const_iterator i(keyword_matches.begin());
+    for (std::vector<string16>::const_iterator i(keyword_matches.begin());
          i != keyword_matches.end(); ++i) {
-      matches_.push_back(CreateAutocompleteMatch(model, *i, input,
-                                                 keyword.length(),
+      matches_.push_back(CreateAutocompleteMatch(model, UTF16ToWideHack(*i),
+                                                 input, keyword.length(),
                                                  remaining_input, -1));
     }
   }
 }
 
 void KeywordProvider::Stop() {
   done_ = true;
   MaybeEndExtensionKeywordMode();
 }
 
 KeywordProvider::~KeywordProvider() {}
 
 // static
 bool KeywordProvider::ExtractKeywordFromInput(const AutocompleteInput& input,
                                               std::wstring* keyword,
                                               std::wstring* remaining_input) {
   if ((input.type() == AutocompleteInput::INVALID) ||
       (input.type() == AutocompleteInput::FORCED_QUERY))
     return false;
 
-  *keyword = TemplateURLModel::CleanUserInputKeyword(
-      SplitKeywordFromInput(input.text(), true, remaining_input));
+  *keyword =
+      UTF16ToWideHack(TemplateURLModel::CleanUserInputKeyword(WideToUTF16Hack(
+          SplitKeywordFromInput(input.text(), true, remaining_input))));
   return !keyword->empty();
 }
 
 // static
 std::wstring KeywordProvider::SplitKeywordFromInput(
     const std::wstring& input,
     bool trim_leading_whitespace,
     std::wstring* remaining_input) {
   // Find end of first token.  The AutocompleteController has trimmed leading
   // whitespace, so we need not skip over that.
@@ skipping 26 matching lines @@
       IDS_EXTENSION_KEYWORD_COMMAND : IDS_KEYWORD_SEARCH;
   if (remaining_input.empty()) {
     // Allow extension keyword providers to accept empty string input. This is
     // useful to allow extensions to do something in the case where no input is
     // entered.
     if (element->url()->SupportsReplacement() &&
         !element->IsExtensionKeyword()) {
       // No query input; return a generic, no-destination placeholder.
       match->contents.assign(UTF16ToWideHack(
           l10n_util::GetStringFUTF16(message_id,
-              WideToUTF16Hack(element->AdjustedShortNameForLocaleDirection()),
+              element->AdjustedShortNameForLocaleDirection(),
               l10n_util::GetStringUTF16(IDS_EMPTY_KEYWORD_VALUE))));
       match->contents_class.push_back(
           ACMatchClassification(0, ACMatchClassification::DIM));
     } else {
       // Keyword that has no replacement text (aka a shorthand for a URL).
       match->destination_url = GURL(element->url()->url());
-      match->contents.assign(element->short_name());
+      match->contents.assign(UTF16ToWideHack(element->short_name()));
       AutocompleteMatch::ClassifyLocationInString(0, match->contents.length(),
           match->contents.length(), ACMatchClassification::NONE,
           &match->contents_class);
     }
   } else {
     // Create destination URL by escaping user input and substituting into
     // keyword template URL.  The escaping here handles whitespace in user
     // input, but we rely on later canonicalization functions to do more
     // fixup to make the URL valid if necessary.
     DCHECK(element->url()->SupportsReplacement());
     match->destination_url = GURL(element->url()->ReplaceSearchTerms(
-      *element, remaining_input, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
-      std::wstring()));
+      *element, WideToUTF16Hack(remaining_input),
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
     std::vector<size_t> content_param_offsets;
     match->contents.assign(UTF16ToWideHack(
         l10n_util::GetStringFUTF16(message_id,
-                                   WideToUTF16Hack(element->short_name()),
+                                   element->short_name(),
                                    WideToUTF16Hack(remaining_input),
                                    &content_param_offsets)));
     if (content_param_offsets.size() == 2) {
       AutocompleteMatch::ClassifyLocationInString(content_param_offsets[1],
           remaining_input.length(), match->contents.length(),
           ACMatchClassification::NONE, &match->contents_class);
     } else {
       // See comments on an identical NOTREACHED() in search_provider.cc.
       NOTREACHED();
     }
@@ skipping 16 matching lines @@
 
 AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
     TemplateURLModel* model,
     const std::wstring& keyword,
     const AutocompleteInput& input,
     size_t prefix_length,
     const std::wstring& remaining_input,
     int relevance) {
   DCHECK(model);
   // Get keyword data from data store.
-  const TemplateURL* element(model->GetTemplateURLForKeyword(keyword));
+  const TemplateURL* element(
+      model->GetTemplateURLForKeyword(WideToUTF16Hack(keyword)));
   DCHECK(element && element->url());
   const bool supports_replacement = element->url()->SupportsReplacement();
 
   // Create an edit entry of "[keyword] [remaining input]".  This is helpful
   // even when [remaining input] is empty, as the user can select the popup
   // choice and immediately begin typing in query input.
   const bool keyword_complete = (prefix_length == keyword.length());
   if (relevance < 0) {
     relevance =
         CalculateRelevance(input.type(), keyword_complete,
@@ skipping 56 matching lines @@
       return;
 
     case NotificationType::EXTENSION_OMNIBOX_DEFAULT_SUGGESTION_CHANGED: {
       // It's possible to change the default suggestion while not in an editing
       // session.
       std::wstring keyword, remaining_input;
       if (matches_.empty() || current_keyword_extension_id_.empty() ||
           !ExtractKeywordFromInput(input, &keyword, &remaining_input))
         return;
 
-      const TemplateURL* template_url(model->GetTemplateURLForKeyword(keyword));
+      const TemplateURL* template_url(
+          model->GetTemplateURLForKeyword(WideToUTF16Hack(keyword)));
       ApplyDefaultSuggestionForExtensionKeyword(profile_, template_url,
                                                 WideToUTF16(remaining_input),
                                                 &matches_[0]);
       listener_->OnProviderUpdate(true);
       return;
     }
 
     case NotificationType::EXTENSION_OMNIBOX_SUGGESTIONS_READY: {
       const ExtensionOmniboxSuggestions& suggestions =
         *Details<ExtensionOmniboxSuggestions>(details).ptr();
@@ skipping 52 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }