Revert 70271 - Remove wstring from l10n_util. Part 3....

chrome/browser/autocomplete/keyword_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/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "app/l10n_util.h"
@@ skipping 300 matching lines @@
   DCHECK(element->url()->IsValid());
   int message_id = element->IsExtensionKeyword() ?
       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()),
-              l10n_util::GetStringUTF16(IDS_EMPTY_KEYWORD_VALUE))));
+      match->contents.assign(l10n_util::GetStringF(message_id,
+          element->AdjustedShortNameForLocaleDirection(),
+          l10n_util::GetString(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());
       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()));
     std::vector<size_t> content_param_offsets;
-    match->contents.assign(UTF16ToWideHack(
-        l10n_util::GetStringFUTF16(message_id,
-                                   WideToUTF16Hack(element->short_name()),
-                                   WideToUTF16Hack(remaining_input),
-                                   &content_param_offsets)));
+    match->contents.assign(l10n_util::GetStringF(message_id,
+                                                 element->short_name(),
+                                                 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 55 matching lines @@
   // Create destination URL and popup entry content by substituting user input
   // into keyword templates.
   FillInURLAndContents(remaining_input, element, &result);
 
   if (supports_replacement)
     result.template_url = element;
   result.transition = PageTransition::KEYWORD;
 
   // Create popup entry description based on the keyword name.
   if (!element->IsExtensionKeyword()) {
-    result.description.assign(UTF16ToWideHack(l10n_util::GetStringFUTF16(
-        IDS_AUTOCOMPLETE_KEYWORD_DESCRIPTION, WideToUTF16Hack(keyword))));
-    string16 keyword_desc(
-        l10n_util::GetStringUTF16(IDS_AUTOCOMPLETE_KEYWORD_DESCRIPTION));
-    AutocompleteMatch::ClassifyLocationInString(
-        keyword_desc.find(ASCIIToUTF16("%s")),
-        prefix_length,
-        result.description.length(),
-        ACMatchClassification::DIM,
-        &result.description_class);
+    result.description.assign(l10n_util::GetStringF(
+        IDS_AUTOCOMPLETE_KEYWORD_DESCRIPTION, keyword));
+    static const std::wstring kKeywordDesc(
+        l10n_util::GetString(IDS_AUTOCOMPLETE_KEYWORD_DESCRIPTION));
+    AutocompleteMatch::ClassifyLocationInString(kKeywordDesc.find(L"%s"),
+                                                prefix_length,
+                                                result.description.length(),
+                                                ACMatchClassification::DIM,
+                                                &result.description_class);
   }
 
   return result;
 }
 
 void KeywordProvider::Observe(NotificationType type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   TemplateURLModel* model = profile_ ? profile_->GetTemplateURLModel() : model_;
   const AutocompleteInput& input = extension_suggest_last_input_;
@@ skipping 79 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }