Remove wstring from TemplateURL and friends....

chrome/browser/search_engines/template_url.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/search_engines/template_url.h"
 
 #include "app/l10n_util.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
@@ skipping 243 matching lines @@
   }
 }
 
 // static
 void TemplateURLRef::SetGoogleBaseURL(std::string* google_base_url) {
   UIThreadSearchTermsData::SetGoogleBaseURL(google_base_url);
 }
 
 std::string TemplateURLRef::ReplaceSearchTerms(
     const TemplateURL& host,
-    const std::wstring& terms,
+    const string16& terms,
     int accepted_suggestion,
-    const std::wstring& original_query_for_suggestion) const {
+    const string16& original_query_for_suggestion) const {
   UIThreadSearchTermsData search_terms_data;
   return ReplaceSearchTermsUsingTermsData(host,
                                           terms,
                                           accepted_suggestion,
                                           original_query_for_suggestion,
                                           search_terms_data);
 }
 
 std::string TemplateURLRef::ReplaceSearchTermsUsingTermsData(
     const TemplateURL& host,
-    const std::wstring& terms,
+    const string16& terms,
     int accepted_suggestion,
-    const std::wstring& original_query_for_suggestion,
+    const string16& original_query_for_suggestion,
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   if (!valid_)
     return std::string();
 
   if (replacements_.empty())
     return parsed_url_;
 
   // Determine if the search terms are in the query or before. We're escaping
   // space as '+' in the former case and as '%20' in the latter case.
   bool is_in_query = true;
   for (Replacements::iterator i = replacements_.begin();
        i != replacements_.end(); ++i) {
     if (i->type == SEARCH_TERMS) {
-      std::wstring::size_type query_start = parsed_url_.find('?');
-      is_in_query = query_start != std::wstring::npos &&
-          (static_cast<std::wstring::size_type>(i->index) > query_start);
+      string16::size_type query_start = parsed_url_.find('?');
+      is_in_query = query_start != string16::npos &&
+          (static_cast<string16::size_type>(i->index) > query_start);
       break;
     }
   }
 
   string16 encoded_terms;
   string16 encoded_original_query;
   std::string input_encoding;
   // If the search terms are in query - escape them respecting the encoding.
   if (is_in_query) {
     // Encode the search terms so that we know the encoding.
     const std::vector<std::string>& encodings = host.input_encodings();
     for (size_t i = 0; i < encodings.size(); ++i) {
-      if (EscapeQueryParamValue(WideToUTF16Hack(terms),
+      if (EscapeQueryParamValue(terms,
                                 encodings[i].c_str(), true,
                                 &encoded_terms)) {
         if (!original_query_for_suggestion.empty()) {
-          EscapeQueryParamValue(WideToUTF16Hack(original_query_for_suggestion),
+          EscapeQueryParamValue(original_query_for_suggestion,
                                 encodings[i].c_str(),
                                 true,
                                 &encoded_original_query);
         }
         input_encoding = encodings[i];
         break;
       }
     }
     if (input_encoding.empty()) {
-      encoded_terms = WideToUTF16Hack(
-          EscapeQueryParamValueUTF8(terms, true));
+      encoded_terms = EscapeQueryParamValueUTF8(terms, true);
       if (!original_query_for_suggestion.empty()) {
         encoded_original_query =
-            WideToUTF16Hack(EscapeQueryParamValueUTF8(
-            original_query_for_suggestion, true));
+            EscapeQueryParamValueUTF8(original_query_for_suggestion, true);
       }
       input_encoding = "UTF-8";
     }
   } else {
-    encoded_terms = WideToUTF16Hack(UTF8ToWide(EscapePath(WideToUTF8(terms))));
+    encoded_terms = UTF8ToUTF16(EscapePath(UTF16ToUTF8(terms)));
     input_encoding = "UTF-8";
   }
 
   std::string url = parsed_url_;
 
   // replacements_ is ordered in ascending order, as such we need to iterate
   // from the back.
   for (Replacements::reverse_iterator i = replacements_.rbegin();
        i != replacements_.rend(); ++i) {
     switch (i->type) {
@@ skipping 21 matching lines @@
           url.insert(i->index, "oq=" + UTF16ToUTF8(encoded_original_query) +
                                "&");
         break;
 
       case GOOGLE_RLZ: {
         // On platforms that don't have RLZ, we still want this branch
         // to happen so that we replace the RLZ template with the
         // empty string.  (If we don't handle this case, we hit a
         // NOTREACHED below.)
 #if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
-        std::wstring rlz_string = search_terms_data.GetRlzParameterValue();
+        string16 rlz_string = search_terms_data.GetRlzParameterValue();
         if (!rlz_string.empty()) {
           rlz_string = L"rlz=" + rlz_string + L"&";
-          url.insert(i->index, WideToUTF8(rlz_string));
+          url.insert(i->index, UTF16ToUTF8(rlz_string));
         }
 #endif
         break;
       }
 
       case GOOGLE_UNESCAPED_SEARCH_TERMS: {
         std::string unescaped_terms;
-        base::WideToCodepage(terms, input_encoding.c_str(),
-                             base::OnStringConversionError::SKIP,
-                             &unescaped_terms);
+        base::UTF16ToCodepage(terms, input_encoding.c_str(),
+                              base::OnStringConversionError::SKIP,
+                              &unescaped_terms);
         url.insert(i->index, std::string(unescaped_terms.begin(),
                                          unescaped_terms.end()));
         break;
       }
 
       case LANGUAGE:
         url.insert(i->index, search_terms_data.GetApplicationLocale());
         break;
 
       case SEARCH_TERMS:
@@ skipping 24 matching lines @@
   UIThreadSearchTermsData search_terms_data;
   return IsValidUsingTermsData(search_terms_data);
 }
 
 bool TemplateURLRef::IsValidUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   return valid_;
 }
 
-std::wstring TemplateURLRef::DisplayURL() const {
+string16 TemplateURLRef::DisplayURL() const {
   ParseIfNecessary();
   if (!valid_ || replacements_.empty())
-    return UTF8ToWide(url_);
+    return UTF8ToUTF16(url_);
 
   string16 result = UTF8ToUTF16(url_);
   ReplaceSubstringsAfterOffset(&result, 0,
                                ASCIIToUTF16(kSearchTermsParameterFull),
                                ASCIIToUTF16(kDisplaySearchTerms));
 
   ReplaceSubstringsAfterOffset(
       &result, 0,
       ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull),
       ASCIIToUTF16(kDisplayUnescapedSearchTerms));
 
-  return UTF16ToWideHack(result);
+  return result;
 }
 
 // static
 std::string TemplateURLRef::DisplayURLToURLRef(
-    const std::wstring& display_url) {
-  string16 result = WideToUTF16Hack(display_url);
+    const string16& display_url) {
+  string16 result = display_url;
   ReplaceSubstringsAfterOffset(&result, 0, ASCIIToUTF16(kDisplaySearchTerms),
                                ASCIIToUTF16(kSearchTermsParameterFull));
   ReplaceSubstringsAfterOffset(
       &result, 0,
       ASCIIToUTF16(kDisplayUnescapedSearchTerms),
       ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull));
   return UTF16ToUTF8(result);
 }
 
 const std::string& TemplateURLRef::GetHost() const {
   ParseIfNecessary();
   return host_;
 }
 
 const std::string& TemplateURLRef::GetPath() const {
   ParseIfNecessary();
   return path_;
 }
 
 const std::string& TemplateURLRef::GetSearchTermKey() const {
   ParseIfNecessary();
   return search_term_key_;
 }
 
-std::wstring TemplateURLRef::SearchTermToWide(const TemplateURL& host,
+string16 TemplateURLRef::SearchTermToString16(const TemplateURL& host,
                                               const std::string& term) const {
   const std::vector<std::string>& encodings = host.input_encodings();
-  std::wstring result;
+  string16 result;
 
   std::string unescaped =
       UnescapeURLComponent(term, UnescapeRule::REPLACE_PLUS_WITH_SPACE |
                                  UnescapeRule::URL_SPECIAL_CHARS);
   for (size_t i = 0; i < encodings.size(); ++i) {
-    if (base::CodepageToWide(unescaped, encodings[i].c_str(),
-                             base::OnStringConversionError::FAIL, &result))
+    if (base::CodepageToUTF16(unescaped, encodings[i].c_str(),
+                              base::OnStringConversionError::FAIL, &result))
       return result;
   }
 
   // Always fall back on UTF-8 if it works.
-  if (base::CodepageToWide(unescaped, base::kCodepageUTF8,
-                           base::OnStringConversionError::FAIL, &result))
+  if (base::CodepageToUTF16(unescaped, base::kCodepageUTF8,
+                            base::OnStringConversionError::FAIL, &result))
     return result;
 
   // When nothing worked, just use the escaped text. We have no idea what the
   // encoding is. We need to substitute spaces for pluses ourselves since we're
   // not sending it through an unescaper.
-  result = UTF8ToWide(term);
+  result = UTF8ToUTF16(term);
   std::replace(result.begin(), result.end(), '+', ' ');
   return result;
 }
 
 bool TemplateURLRef::HasGoogleBaseURLs() const {
   ParseIfNecessary();
   for (size_t i = 0; i < replacements_.size(); ++i) {
     if ((replacements_[i].type == GOOGLE_BASE_URL) ||
         (replacements_[i].type == GOOGLE_BASE_SUGGEST_URL))
       return true;
@@ skipping 57 matching lines @@
       created_by_policy_(false),
       usage_count_(0),
       search_engine_type_(SEARCH_ENGINE_OTHER),
       logo_id_(kNoSearchEngineLogo),
       prepopulate_id_(0) {
 }
 
 TemplateURL::~TemplateURL() {
 }
 
-std::wstring TemplateURL::AdjustedShortNameForLocaleDirection() const {
-  std::wstring bidi_safe_short_name = short_name_;
+string16 TemplateURL::AdjustedShortNameForLocaleDirection() const {
+  string16 bidi_safe_short_name = short_name_;
   base::i18n::AdjustStringForLocaleDirection(&bidi_safe_short_name);
   return bidi_safe_short_name;
 }
 
 void TemplateURL::SetSuggestionsURL(const std::string& suggestions_url,
                                     int index_offset,
                                     int page_offset) {
   suggestions_url_.Set(suggestions_url, index_offset, page_offset);
 }
 
 void TemplateURL::SetURL(const std::string& url,
                          int index_offset,
                          int page_offset) {
   url_.Set(url, index_offset, page_offset);
 }
 
 void TemplateURL::SetInstantURL(const std::string& url,
                                 int index_offset,
                                 int page_offset) {
   instant_url_.Set(url, index_offset, page_offset);
 }
 
-void TemplateURL::set_keyword(const std::wstring& keyword) {
+void TemplateURL::set_keyword(const string16& keyword) {
   // Case sensitive keyword matching is confusing. As such, we force all
   // keywords to be lower case.
-  keyword_ = UTF16ToWide(l10n_util::ToLower(WideToUTF16(keyword)));
+  keyword_ = l10n_util::ToLower(keyword);
   autogenerate_keyword_ = false;
 }
 
-const std::wstring& TemplateURL::keyword() const {
+string16 TemplateURL::keyword() const {
   EnsureKeyword();
   return keyword_;
 }
 
 void TemplateURL::EnsureKeyword() const {
   if (autogenerate_keyword_ && !keyword_generated_) {
     // Generate a keyword and cache it.
     keyword_ = TemplateURLModel::GenerateKeyword(
         TemplateURLModel::GenerateSearchURL(this).GetWithEmptyPath(), true);
     keyword_generated_ = true;
   }
 }
 
 bool TemplateURL::ShowInDefaultList() const {
   return show_in_default_list() && url() && url()->SupportsReplacement();
 }
 
 void TemplateURL::SetFavIconURL(const GURL& url) {
   for (std::vector<ImageRef>::iterator i = image_refs_.begin();
        i != image_refs_.end(); ++i) {
-    if (i->type == L"image/x-icon" &&
+    if (i->type == "image/x-icon" &&
         i->width == kFavIconSize && i->height == kFavIconSize) {
       if (!url.is_valid())
         image_refs_.erase(i);
       else
         i->url = url;
       return;
     }
   }
   // Don't have one yet, add it.
   if (url.is_valid()) {
     add_image_ref(
-        TemplateURL::ImageRef(L"image/x-icon", kFavIconSize, kFavIconSize,
-                              url));
+        TemplateURL::ImageRef("image/x-icon", kFavIconSize,
+                              kFavIconSize, url));
   }
 }
 
 GURL TemplateURL::GetFavIconURL() const {
   for (std::vector<ImageRef>::const_iterator i = image_refs_.begin();
        i != image_refs_.end(); ++i) {
-    if ((i->type == L"image/x-icon" || i->type == L"image/vnd.microsoft.icon")
+    if ((i->type == "image/x-icon" || i->type == "image/vnd.microsoft.icon")
         && i->width == kFavIconSize && i->height == kFavIconSize) {
       return i->url;
     }
   }
   return GURL();
 }
 
 void TemplateURL::InvalidateCachedValues() const {
   url_.InvalidateCachedValues();
   suggestions_url_.InvalidateCachedValues();
   if (autogenerate_keyword_) {
     keyword_.clear();
     keyword_generated_ = false;
   }
 }
 
 std::string TemplateURL::GetExtensionId() const {
   DCHECK(IsExtensionKeyword());
   return GURL(url_.url()).host();
 }
 
 bool TemplateURL::IsExtensionKeyword() const {
   return GURL(url_.url()).SchemeIs(chrome::kExtensionScheme);
 }