Remove wstring from TemplateURL and friends....

chrome/browser/search_engines/template_url_parser.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_parser.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 119 matching lines @@
     // We only expect PARAM nodes under the Url node
     if (elements_.size() == 3 && elements_[0] == OPEN_SEARCH_DESCRIPTION &&
         elements_[1] == URL && elements_[2] == PARAM)
       return PARAM;
 
     return UNKNOWN;
   }
 
   TemplateURL* template_url() { return url_; }
 
-  void AddImageRef(const std::wstring& type, int width, int height) {
+  void AddImageRef(const std::string& type, int width, int height) {
     if (width > 0 && height > 0)
       current_image_.reset(new TemplateURL::ImageRef(type, width, height));
   }
 
   void EndImage() {
     current_image_.reset();
   }
 
-  void SetImageURL(const std::wstring& url) {
+  void SetImageURL(const GURL& url) {
     if (current_image_.get()) {
-      current_image_->url = GURL(WideToUTF8(url));
+      current_image_->url = url;
       url_->add_image_ref(*current_image_);
       current_image_.reset();
     }
   }
 
   void ResetString() {
     string_.clear();
   }
 
-  void AppendString(const std::wstring& string) {
+  void AppendString(const string16& string) {
     string_ += string;
   }
 
-  const std::wstring& GetString() {
+  const string16& GetString() {
     return string_;
   }
 
   void ResetExtraParams() {
     extra_params_.clear();
   }
 
   void AddExtraParams(const std::string& key, const std::string& value) {
     if (parameter_filter_ && !parameter_filter_->KeepParameter(key, value))
       return;
@@ skipping 49 matching lines @@
 
   // Key is UTF8 encoded.
   static std::map<std::string, ElementType>* kElementNameToElementTypeMap;
   // TemplateURL supplied to Read method. It's owned by the caller, so we
   // don't need to free it.
   TemplateURL* url_;
   std::vector<ElementType> elements_;
   scoped_ptr<TemplateURL::ImageRef> current_image_;
 
   // Character content for the current element.
-  std::wstring string_;
+  string16 string_;
 
   TemplateURLParser::ParameterFilter* parameter_filter_;
 
   // The list of parameters parsed in the Param nodes of a Url node.
   std::vector<Param> extra_params_;
 
   // The HTTP methods used.
   Method method_;
   Method suggestion_method_;
 
   // If true, we are currently parsing a suggest URL, otherwise it is an HTML
   // search.  Note that we don't need a stack as Url nodes cannot be nested.
   bool is_suggest_url_;
 
   // Whether we should derive the image from the URL (when images are data
   // URLs).
   bool derive_image_from_url_;
 
   DISALLOW_COPY_AND_ASSIGN(ParsingContext);
 };
 
 // static
 std::map<std::string, ParsingContext::ElementType>*
     ParsingContext::kElementNameToElementTypeMap = NULL;
 
-std::wstring XMLCharToWide(const xmlChar* value) {
-  return UTF8ToWide(std::string((const char*)value));
-}
-
-std::wstring XMLCharToWide(const xmlChar* value, int length) {
-  return UTF8ToWide(std::string((const char*)value, length));
+string16 XMLCharToUTF16(const xmlChar* value, int length) {
+  return UTF8ToUTF16(std::string((const char*)value, length));
 }
 
 std::string XMLCharToString(const xmlChar* value) {
   return std::string((const char*)value);
 }
 
 // Returns true if input_encoding contains a valid input encoding string. This
 // doesn't verify that we have a valid encoding for the string, just that the
 // string contains characters that constitute a valid input encoding.
 bool IsValidEncodingString(const std::string& input_encoding) {
@@ skipping 59 matching lines @@
   }
 }
 
 void ParseImage(const xmlChar** atts, ParsingContext* context) {
   if (!atts)
     return;
 
   const xmlChar** attributes = atts;
   int width = 0;
   int height = 0;
-  std::wstring type;
+  std::string type;
   while (*attributes) {
     std::string name(XMLCharToString(*attributes));
     const xmlChar* value = attributes[1];
     if (name == kImageTypeAttribute) {
-      type = XMLCharToWide(value);
+      type = XMLCharToString(value);
     } else if (name == kImageWidthAttribute) {
       base::StringToInt(XMLCharToString(value), &width);
     } else if (name == kImageHeightAttribute) {
       base::StringToInt(XMLCharToString(value), &height);
     }
     attributes += 2;
   }
   if (width > 0 && height > 0 && !type.empty()) {
     // Valid Image URL.
     context->AddImageRef(type, width, height);
   }
 }
 
 void ParseParam(const xmlChar** atts, ParsingContext* context) {
   if (!atts)
     return;
 
   const xmlChar** attributes = atts;
-  std::wstring type;
   std::string key, value;
   while (*attributes) {
     std::string name(XMLCharToString(*attributes));
     const xmlChar* val = attributes[1];
     if (name == kParamNameAttribute) {
       key = XMLCharToString(val);
     } else if (name == kParamValueAttribute) {
       value = XMLCharToString(val);
     }
     attributes += 2;
@@ skipping 98 matching lines @@
 void EndElementImpl(void *ctx, const xmlChar *name) {
   ParsingContext* context = reinterpret_cast<ParsingContext*>(ctx);
   switch (context->GetKnownType()) {
     case ParsingContext::SHORT_NAME:
       context->template_url()->set_short_name(context->GetString());
       break;
     case ParsingContext::DESCRIPTION:
       context->template_url()->set_description(context->GetString());
       break;
     case ParsingContext::IMAGE: {
-      GURL image_url(WideToUTF8(context->GetString()));
+      GURL image_url(UTF16ToUTF8(context->GetString()));
       if (image_url.SchemeIs(chrome::kDataScheme)) {
         // TODO (jcampan): bug 1169256: when dealing with data URL, we need to
         // decode the data URL in the renderer. For now, we'll just point to the
         // fav icon from the URL.
         context->set_derive_image_from_url(true);
       } else {
-        context->SetImageURL(context->GetString());
+        context->SetImageURL(image_url);
       }
       context->EndImage();
       break;
     }
     case ParsingContext::LANGUAGE:
       context->template_url()->add_language(context->GetString());
       break;
     case ParsingContext::INPUT_ENCODING: {
-      std::string input_encoding = WideToASCII(context->GetString());
+      std::string input_encoding = UTF16ToASCII(context->GetString());
       if (IsValidEncodingString(input_encoding))
         context->template_url()->add_input_encoding(input_encoding);
       break;
     }
     case ParsingContext::URL:
       ProcessURLParams(context);
       break;
     default:
       break;
   }
   context->ResetString();
   context->PopElement();
 }
 
 void CharactersImpl(void *ctx, const xmlChar *ch, int len) {
   ParsingContext* context = reinterpret_cast<ParsingContext*>(ctx);
-  context->AppendString(XMLCharToWide(ch, len));
+  context->AppendString(XMLCharToUTF16(ch, len));
 }
 
 // Returns true if the ref is null, or the url wrapped by ref is
 // valid with a spec of http/https.
 bool IsHTTPRef(const TemplateURLRef* ref) {
   if (ref == NULL)
     return true;
   GURL url(ref->url());
   return (url.is_valid() && (url.SchemeIs(chrome::kHttpScheme) ||
                              url.SchemeIs(chrome::kHttpsScheme)));
@@ skipping 49 matching lines @@
     return false;
   if (context.suggestion_method() == ParsingContext::POST)
     url->SetSuggestionsURL("", 0, 0);
 
   if (!url->short_name().empty() && !url->description().empty()) {
     // So far so good, make sure the urls are http.
     return IsLegal(url);
   }
   return false;
 }