Porting in browser/webdata and template_url.

chrome/browser/template_url_model.cc

 // Copyright (c) 2006-2008 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/template_url_model.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 14 matching lines @@
 #include "net/base/net_util.h"
 #include "unicode/rbbi.h"
 #include "unicode/uchar.h"
 
 using base::Time;
 
 // String in the URL that is replaced by the search term.
 static const wchar_t kSearchTermParameter[] = L"{searchTerms}";
 
 // String in Initializer that is replaced with kSearchTermParameter.
-static const wchar_t kTemplateParameter[](L"%s");
+static const wchar_t kTemplateParameter[] = L"%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";
 
 class TemplateURLModel::LessWithPrefix {
  public:
   // We want to find the set of keywords that begin with a prefix.  The STL
   // algorithms will return the set of elements that are "equal to" the
@@ skipping 120 matching lines @@
   // properly.  See http://b/issue?id=1205573.
   return net::StripWWW(UTF8ToWide(url.host()));
 }
 
 // static
 std::wstring TemplateURLModel::CleanUserInputKeyword(
     const std::wstring& keyword) {
   // Remove the scheme.
   std::wstring result(l10n_util::ToLower(keyword));
   url_parse::Component scheme_component;
-  if (url_parse::ExtractScheme(keyword.c_str(),
+  if (url_parse::ExtractScheme(WideToUTF8(keyword).c_str(),
                                static_cast<int>(keyword.length()),
                                &scheme_component)) {
     // 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"//");
     if (result.compare(0, after_scheme.length(), after_scheme) == 0)
       result.erase(0, after_scheme.length());
   }
 
   // Remove leading "www.".
   result = net::StripWWW(result);
 
   // Remove trailing "/".
   return (result.length() > 0 && result[result.length() - 1] == L'/') ?
       result.substr(0, result.length() - 1) : result;
 }
 
 // static
 GURL TemplateURLModel::GenerateSearchURL(const TemplateURL* t_url) {
   DCHECK(t_url);
   const TemplateURLRef* search_ref = t_url->url();
   if (!search_ref || !search_ref->IsValid())
     return GURL();
 
   if (!search_ref->SupportsReplacement())
-    return GURL(search_ref->url());
+    return GURL(WideToUTF8(search_ref->url()));
 
-  return GURL(search_ref->ReplaceSearchTerms(*t_url, kReplacementTerm,
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring()));
+  return search_ref->ReplaceSearchTerms(
+      *t_url,
+      kReplacementTerm,
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring());
 }
 
 bool TemplateURLModel::CanReplaceKeyword(
     const std::wstring& keyword,
     const std::wstring& 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.
-  GURL gurl(url);
+  GURL gurl(WideToUTF8(url));
   if (gurl.is_valid() && !gurl.host().empty())
     return CanReplaceKeywordForHost(gurl.host(), template_url_to_replace);
   return true;
 }
 
 void TemplateURLModel::FindMatchingKeywords(
     const std::wstring& prefix,
     bool support_replacement_only,
     std::vector<std::wstring>* matches) const {
   // Sanity check args.
@@ skipping 727 matching lines @@
       AddToMaps(t_url);
       something_changed = true;
     }
   }
 
   if (something_changed && loaded_) {
     FOR_EACH_OBSERVER(TemplateURLModelObserver, model_observers_,
                       OnTemplateURLModelChanged());
   }
 }