Remove wstring from TemplateURL and friends....

chrome/browser/search_engines/template_url_model.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_model.h"
 
 #include "app/l10n_util.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
@@ skipping 27 matching lines @@
 
 // String in the URL that is replaced by the search term.
 static const char kSearchTermParameter[] = "{searchTerms}";
 
 // String in Initializer that is replaced with kSearchTermParameter.
 static const char kTemplateParameter[] = "%s";
 
 // Term used when generating a search url. Use something obscure so that on
 // the rare case the term replaces the URL it's unlikely another keyword would
 // have the same url.
-static const wchar_t kReplacementTerm[] = L"blah.blah.blah.blah.blah";
+static const char kReplacementTerm[] = "blah.blah.blah.blah.blah";
 
 
 // Removes from the vector any template URL that was created because of
 // policy.  These TemplateURLs are freed.
 // Sets default_search_provider to NULL if it was one of them.
 static void RemoveProvidersCreatedByPolicy(
     std::vector<TemplateURL*>* template_urls,
     const TemplateURL** default_search_provider) {
   DCHECK(template_urls);
   DCHECK(default_search_provider);
@@ skipping 62 matching lines @@
 TemplateURLModel::~TemplateURLModel() {
   if (load_handle_) {
     DCHECK(service_.get());
     service_->CancelRequest(load_handle_);
   }
 
   STLDeleteElements(&template_urls_);
 }
 
 // static
-std::wstring TemplateURLModel::GenerateKeyword(const GURL& url,
-                                               bool autodetected) {
+string16 TemplateURLModel::GenerateKeyword(const GURL& url,
+                                           bool autodetected) {
   // Don't autogenerate keywords for referrers that are the result of a form
   // submission (TODO: right now we approximate this by checking for the URL
   // having a query, but we should replace this with a call to WebCore to see if
   // the originating page was actually a form submission), anything other than
   // http, or referrers with a path.
   //
   // If we relax the path constraint, we need to be sure to sanitize the path
   // elements and update AutocompletePopup to look for keywords using the path.
   // See http://b/issue?id=863583.
   if (!url.is_valid() ||
       (autodetected && (url.has_query() || !url.SchemeIs(chrome::kHttpScheme) ||
                         ((url.path() != "") && (url.path() != "/")))))
-    return std::wstring();
+    return string16();
 
   // Strip "www." off the front of the keyword; otherwise the keyword won't work
   // properly.  See http://code.google.com/p/chromium/issues/detail?id=6984 .
-  return UTF16ToWideHack(net::StripWWW(UTF8ToUTF16(url.host())));
+  return net::StripWWW(UTF8ToUTF16(url.host()));
 }
 
 // static
-std::wstring TemplateURLModel::CleanUserInputKeyword(
-    const std::wstring& keyword) {
+string16 TemplateURLModel::CleanUserInputKeyword(const string16& keyword) {
   // Remove the scheme.
-  std::wstring result(UTF16ToWide(l10n_util::ToLower(WideToUTF16(keyword))));
+  string16 result(l10n_util::ToLower(keyword));
   url_parse::Component scheme_component;
-  if (url_parse::ExtractScheme(WideToUTF8(keyword).c_str(),
+  if (url_parse::ExtractScheme(UTF16ToUTF8(keyword).c_str(),
                                static_cast<int>(keyword.length()),
                                &scheme_component)) {
     // If the scheme isn't "http" or "https", bail.  The user isn't trying to
     // type a web address, but rather an FTP, file:, or other scheme URL, or a
     // search query with some sort of initial operator (e.g. "site:").
     if (result.compare(0, scheme_component.end(),
-                       ASCIIToWide(chrome::kHttpScheme)) &&
+                       ASCIIToUTF16(chrome::kHttpScheme)) &&
         result.compare(0, scheme_component.end(),
-                       ASCIIToWide(chrome::kHttpsScheme)))
-      return std::wstring();
+                       ASCIIToUTF16(chrome::kHttpsScheme)))
+      return string16();
 
     // Include trailing ':'.
     result.erase(0, scheme_component.end() + 1);
     // Many schemes usually have "//" after them, so strip it too.
-    const std::wstring after_scheme(L"//");
+    const string16 after_scheme(ASCIIToUTF16("//"));
     if (result.compare(0, after_scheme.length(), after_scheme) == 0)
       result.erase(0, after_scheme.length());
   }
 
   // Remove leading "www.".
-  result = UTF16ToWideHack(net::StripWWW(WideToUTF16(result)));
+  result = net::StripWWW(result);
 
   // Remove trailing "/".
-  return (result.length() > 0 && result[result.length() - 1] == L'/') ?
+  return (result.length() > 0 && result[result.length() - 1] == '/') ?
       result.substr(0, result.length() - 1) : result;
 }
 
 // static
 GURL TemplateURLModel::GenerateSearchURL(const TemplateURL* t_url) {
   DCHECK(t_url);
   UIThreadSearchTermsData search_terms_data;
   return GenerateSearchURLUsingTermsData(t_url, search_terms_data);
 }
 
 // static
 GURL TemplateURLModel::GenerateSearchURLUsingTermsData(
     const TemplateURL* t_url,
     const SearchTermsData& search_terms_data) {
   DCHECK(t_url);
   const TemplateURLRef* search_ref = t_url->url();
   // Extension keywords don't have host-based search URLs.
   if (!search_ref || !search_ref->IsValidUsingTermsData(search_terms_data) ||
       t_url->IsExtensionKeyword())
     return GURL();
 
   if (!search_ref->SupportsReplacementUsingTermsData(search_terms_data))
     return GURL(search_ref->url());
 
   return GURL(search_ref->ReplaceSearchTermsUsingTermsData(
-      *t_url, kReplacementTerm, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
-      std::wstring(), search_terms_data));
+      *t_url, ASCIIToUTF16(kReplacementTerm),
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
+      string16(), search_terms_data));
 }
 
 bool TemplateURLModel::CanReplaceKeyword(
-    const std::wstring& keyword,
+    const string16& keyword,
     const GURL& url,
     const TemplateURL** template_url_to_replace) {
   DCHECK(!keyword.empty());  // This should only be called for non-empty
                              // keywords. If we need to support empty kewords
                              // the code needs to change slightly.
   const TemplateURL* existing_url = GetTemplateURLForKeyword(keyword);
   if (existing_url) {
     // We already have a TemplateURL for this keyword. Only allow it to be
     // replaced if the TemplateURL can be replaced.
     if (template_url_to_replace)
       *template_url_to_replace = existing_url;
     return CanReplace(existing_url);
   }
 
   // We don't have a TemplateURL with keyword. Only allow a new one if there
   // isn't a TemplateURL for the specified host, or there is one but it can
   // be replaced. We do this to ensure that if the user assigns a different
   // keyword to a generated TemplateURL, we won't regenerate another keyword for
   // the same host.
   if (url.is_valid() && !url.host().empty())
     return CanReplaceKeywordForHost(url.host(), template_url_to_replace);
   return true;
 }
 
 void TemplateURLModel::FindMatchingKeywords(
-    const std::wstring& prefix,
+    const string16& prefix,
     bool support_replacement_only,
-    std::vector<std::wstring>* matches) const {
+    std::vector<string16>* matches) const {
   // Sanity check args.
   if (prefix.empty())
     return;
   DCHECK(matches != NULL);
   DCHECK(matches->empty());  // The code for exact matches assumes this.
 
   // Find matching keyword range.  Searches the element map for keywords
   // beginning with |prefix| and stores the endpoints of the resulting set in
   // |match_range|.
   const std::pair<KeywordToTemplateMap::const_iterator,
                   KeywordToTemplateMap::const_iterator> match_range(
       std::equal_range(
           keyword_to_template_map_.begin(), keyword_to_template_map_.end(),
           KeywordToTemplateMap::value_type(prefix, NULL), LessWithPrefix()));
 
   // Return vector of matching keywords.
   for (KeywordToTemplateMap::const_iterator i(match_range.first);
        i != match_range.second; ++i) {
     DCHECK(i->second->url());
     if (!support_replacement_only || i->second->url()->SupportsReplacement())
       matches->push_back(i->first);
   }
 }
 
 const TemplateURL* TemplateURLModel::GetTemplateURLForKeyword(
-                                     const std::wstring& keyword) const {
+                                     const string16& keyword) const {
   KeywordToTemplateMap::const_iterator elem(
       keyword_to_template_map_.find(keyword));
   return (elem == keyword_to_template_map_.end()) ? NULL : elem->second;
 }
 
 const TemplateURL* TemplateURLModel::GetTemplateURLForHost(
     const std::string& host) const {
   return provider_map_.GetTemplateURLForHost(host);
 }
 
@@ skipping 34 matching lines @@
   if (extension->omnibox_keyword().empty())
     return;
 
   Load();
   if (!loaded_) {
     pending_extension_ids_.push_back(extension->id());
     return;
   }
 
   const TemplateURL* existing_url = GetTemplateURLForExtension(extension);
-  std::wstring keyword = UTF8ToWide(extension->omnibox_keyword());
+  string16 keyword = UTF8ToUTF16(extension->omnibox_keyword());
 
   scoped_ptr<TemplateURL> template_url(new TemplateURL);
-  template_url->set_short_name(UTF8ToWide(extension->name()));
+  template_url->set_short_name(UTF8ToUTF16(extension->name()));
   template_url->set_keyword(keyword);
   // This URL is not actually used for navigation. It holds the extension's
   // ID, as well as forcing the TemplateURL to be treated as a search keyword.
   template_url->SetURL(
       std::string(chrome::kExtensionScheme) + "://" +
       extension->id() + "/?q={searchTerms}", 0, 0);
   template_url->set_safe_for_autoreplace(false);
 
   if (existing_url) {
     // TODO(mpcomplete): only replace if the user hasn't changed the keyword.
@@ skipping 28 matching lines @@
 
 void TemplateURLModel::IncrementUsageCount(const TemplateURL* url) {
   DCHECK(url && find(template_urls_.begin(), template_urls_.end(), url) !=
          template_urls_.end());
   const_cast<TemplateURL*>(url)->set_usage_count(url->usage_count() + 1);
   if (service_.get())
     service_.get()->UpdateKeyword(*url);
 }
 
 void TemplateURLModel::ResetTemplateURL(const TemplateURL* url,
-                                        const std::wstring& title,
-                                        const std::wstring& keyword,
+                                        const string16& title,
+                                        const string16& keyword,
                                         const std::string& search_url) {
   TemplateURL new_url(*url);
   new_url.set_short_name(title);
   new_url.set_keyword(keyword);
   if ((new_url.url() && search_url.empty()) ||
       (!new_url.url() && !search_url.empty()) ||
       (new_url.url() && new_url.url()->url() != search_url)) {
     // The urls have changed, reset the favicon url.
     new_url.SetFavIconURL(GURL());
     new_url.SetURL(search_url, 0, 0);
@@ skipping 144 matching lines @@
     UpdateKeywordSearchTermsForURL(visits_to_add_[i]);
   visits_to_add_.clear();
 
   if (new_resource_keyword_version && service_.get())
     service_->SetBuiltinKeywordVersion(new_resource_keyword_version);
 
   NotifyObservers();
   NotifyLoaded();
 }
 
-std::wstring TemplateURLModel::GetKeywordShortName(const std::wstring& keyword,
-                                                   bool* is_extension_keyword) {
+string16 TemplateURLModel::GetKeywordShortName(const string16& keyword,
+                                               bool* is_extension_keyword) {
   const TemplateURL* template_url = GetTemplateURLForKeyword(keyword);
 
   // TODO(sky): Once LocationBarView adds a listener to the TemplateURLModel
   // to track changes to the model, this should become a DCHECK.
   if (template_url) {
     *is_extension_keyword = template_url->IsExtensionKeyword();
     return template_url->AdjustedShortNameForLocaleDirection();
   }
   *is_extension_keyword = false;
-  return std::wstring();
+  return string16();
 }
 
 void TemplateURLModel::Observe(NotificationType type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
   if (type == NotificationType::HISTORY_URL_VISITED) {
     Details<history::URLVisitedDetails> visit_details(details);
     if (!loaded())
       visits_to_add_.push_back(*visit_details.ptr());
     else
@@ skipping 32 matching lines @@
   prefs->RegisterStringPref(
       prefs::kDefaultSearchProviderKeyword, std::string());
   prefs->RegisterStringPref(
       prefs::kDefaultSearchProviderIconURL, std::string());
   prefs->RegisterStringPref(
       prefs::kDefaultSearchProviderEncodings, std::string());
 }
 
 void TemplateURLModel::SetKeywordSearchTermsForURL(const TemplateURL* t_url,
                                                    const GURL& url,
-                                                   const std::wstring& term) {
+                                                   const string16& term) {
   HistoryService* history = profile_  ?
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS) : NULL;
   if (!history)
     return;
-  history->SetKeywordSearchTermsForURL(url, t_url->id(), WideToUTF16Hack(term));
+  history->SetKeywordSearchTermsForURL(url, t_url->id(), term);
 }
 
 void TemplateURLModel::Init(const Initializer* initializers,
                             int num_initializers) {
   // Register for notifications.
   if (profile_) {
     // TODO(sky): bug 1166191. The keywords should be moved into the history
     // db, which will mean we no longer need this notification and the history
     // backend can handle automatically adding the search terms as the user
     // navigates.
@@ skipping 12 matching lines @@
     ChangeToLoadedState();
 
     // Add specific initializers, if any.
     for (int i(0); i < num_initializers; ++i) {
       DCHECK(initializers[i].keyword);
       DCHECK(initializers[i].url);
       DCHECK(initializers[i].content);
 
       size_t template_position =
           std::string(initializers[i].url).find(kTemplateParameter);
-      DCHECK(template_position != std::wstring::npos);
+      DCHECK(template_position != std::string::npos);
       std::string osd_url(initializers[i].url);
       osd_url.replace(template_position, arraysize(kTemplateParameter) - 1,
                       kSearchTermParameter);
 
       // TemplateURLModel ends up owning the TemplateURL, don't try and free it.
       TemplateURL* template_url = new TemplateURL();
-      template_url->set_keyword(initializers[i].keyword);
-      template_url->set_short_name(initializers[i].content);
+      template_url->set_keyword(UTF8ToUTF16(initializers[i].keyword));
+      template_url->set_short_name(UTF8ToUTF16(initializers[i].content));
       template_url->SetURL(osd_url, 0, 0);
       AddNoNotify(template_url);
     }
   }
 
   // Initialize default search.
   UpdateDefaultSearch();
 
   // Request a server check for the correct Google URL if Google is the
   // default search engine, not in headless mode and not in Chrome Frame.
@@ skipping 108 matching lines @@
     if (t_url->url())
       search_url = t_url->url()->url();
     if (t_url->suggestions_url())
       suggest_url = t_url->suggestions_url()->url();
     if (t_url->instant_url())
       instant_url = t_url->instant_url()->url();
     GURL icon_gurl = t_url->GetFavIconURL();
     if (!icon_gurl.is_empty())
       icon_url = icon_gurl.spec();
     encodings = JoinString(t_url->input_encodings(), ';');
-    short_name = WideToUTF8(t_url->short_name());
-    keyword = WideToUTF8(t_url->keyword());
+    short_name = UTF16ToUTF8(t_url->short_name());
+    keyword = UTF16ToUTF8(t_url->keyword());
     id_string = base::Int64ToString(t_url->id());
     prepopulate_id = base::Int64ToString(t_url->prepopulate_id());
   }
   prefs->SetBoolean(prefs::kDefaultSearchProviderEnabled, enabled);
   prefs->SetString(prefs::kDefaultSearchProviderSearchURL, search_url);
   prefs->SetString(prefs::kDefaultSearchProviderSuggestURL, suggest_url);
   prefs->SetString(prefs::kDefaultSearchProviderInstantURL, instant_url);
   prefs->SetString(prefs::kDefaultSearchProviderIconURL, icon_url);
   prefs->SetString(prefs::kDefaultSearchProviderEncodings, encodings);
   prefs->SetString(prefs::kDefaultSearchProviderName, short_name);
@@ skipping 23 matching lines @@
       prefs->GetString(prefs::kDefaultSearchProviderSearchURL);
   std::string instant_url =
       prefs->GetString(prefs::kDefaultSearchProviderInstantURL);
 
   if (!enabled || (suggest_url.empty() && search_url.empty())) {
     // The user doesn't want a default search provider.
     default_provider->reset(NULL);
     return true;
   }
 
-  std::wstring name =
-      UTF8ToWide(prefs->GetString(prefs::kDefaultSearchProviderName));
-  std::wstring keyword =
-      UTF8ToWide(prefs->GetString(prefs::kDefaultSearchProviderKeyword));
+  string16 name =
+      UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderName));
+  string16 keyword =
+      UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderKeyword));
   std::string icon_url =
       prefs->GetString(prefs::kDefaultSearchProviderIconURL);
   std::string encodings =
       prefs->GetString(prefs::kDefaultSearchProviderEncodings);
   std::string id_string = prefs->GetString(prefs::kDefaultSearchProviderID);
   std::string prepopulate_id =
       prefs->GetString(prefs::kDefaultSearchProviderPrepopulateID);
 
   default_provider->reset(new TemplateURL());
   (*default_provider)->set_short_name(name);
@@ skipping 137 matching lines @@
         // KEYWORD_GENERATED visit for the KEYWORD so that the keyword typed
         // count is boosted.
         AddTabToSearchVisit(**i);
       }
 
       QueryTerms::iterator terms_iterator =
           query_terms.find(search_ref->GetSearchTermKey());
       if (terms_iterator != query_terms.end() &&
           !terms_iterator->second.empty()) {
         SetKeywordSearchTermsForURL(
-            *i, row.url(), search_ref->SearchTermToWide(*(*i),
+            *i, row.url(), search_ref->SearchTermToString16(*(*i),
             terms_iterator->second));
       }
     }
   }
 }
 
 void TemplateURLModel::AddTabToSearchVisit(const TemplateURL& t_url) {
   // Only add visits for entries the user hasn't modified. If the user modified
   // the entry the keyword may no longer correspond to the host name. It may be
   // possible to do something more sophisticated here, but it's so rare as to
   // not be worth it.
   if (!t_url.safe_for_autoreplace())
     return;
 
   if (!profile_)
     return;
 
   HistoryService* history =
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   if (!history)
     return;
 
-  GURL url(URLFixerUpper::FixupURL(WideToUTF8(t_url.keyword()), std::string()));
+  GURL url(URLFixerUpper::FixupURL(UTF16ToUTF8(t_url.keyword()),
+                                   std::string()));
   if (!url.is_valid())
     return;
 
   // Synthesize a visit for the keyword. This ensures the url for the keyword is
   // autocompleted even if the user doesn't type the url in directly.
   history->AddPage(url, NULL, 0, GURL(),
                    PageTransition::KEYWORD_GENERATED,
                    history::RedirectList(), history::SOURCE_BROWSED, false);
 }
 
@@ skipping 231 matching lines @@
   delete template_url;
 }
 
 void TemplateURLModel::NotifyObservers() {
   if (!loaded_)
     return;
 
   FOR_EACH_OBSERVER(TemplateURLModelObserver, model_observers_,
                     OnTemplateURLModelChanged());
 }