Remove wstring from TemplateURL and friends....

chrome/browser/importer/importer_messages.h

-// 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.
 
 #ifndef CHROME_BROWSER_IMPORTER_IMPORTER_MESSAGES_H_
 #define CHROME_BROWSER_IMPORTER_IMPORTER_MESSAGES_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
@@ skipping 203 matching lines @@
 template <>
 struct ParamTraits<TemplateURL::ImageRef> {
   typedef TemplateURL::ImageRef param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.type);
     WriteParam(m, p.width);
     WriteParam(m, p.height);
     WriteParam(m, p.url);
   }
   static bool Read(const Message* m, void** iter, param_type* p) {
-    std::wstring type;
+    std::string type;
     int width;
     int height;
     GURL url;
     if (!ReadParam(m, iter, &type) ||
         !ReadParam(m, iter, &width) ||
         !ReadParam(m, iter, &height) ||
         !ReadParam(m, iter, &url))
       return false;
     *p = TemplateURL::ImageRef(type, width, height, url);  // here in
     return true;
@@ skipping 32 matching lines @@
       WriteParam(m, iter->url);
     }
 
     WriteParam(m, p.languages());
     WriteParam(m, p.input_encodings());
     WriteParam(m, p.date_created());
     WriteParam(m, p.usage_count());
     WriteParam(m, p.prepopulate_id());
   }
   static bool Read(const Message* m, void** iter, param_type* p) {
-    std::wstring short_name;
-    std::wstring description;
+    string16 short_name;
+    string16 description;
     bool includes_suggestions_url;
     TemplateURLRef suggestions_url;
     TemplateURLRef url;
     GURL originating_url;
-    std::wstring keyword;
+    string16 keyword;
     bool autogenerate_keyword;
     bool show_in_default_list;
     bool safe_for_autoreplace;
-    std::vector<std::wstring> languages;
+    std::vector<string16> languages;
     std::vector<std::string> input_encodings;
     base::Time date_created;
     int usage_count;
     int prepopulate_id;
 
     if (!ReadParam(m, iter, &short_name) ||
         !ReadParam(m, iter, &description))
       return false;
 
     if (!ReadParam(m, iter, &includes_suggestions_url))
       return false;
     if (includes_suggestions_url) {
         if (!ReadParam(m, iter, &suggestions_url))
           return false;
     }
 
     size_t image_refs_size = 0;
     if (!ReadParam(m, iter, &url) ||
         !ReadParam(m, iter, &originating_url) ||
         !ReadParam(m, iter, &keyword) ||
         !ReadParam(m, iter, &autogenerate_keyword) ||
         !ReadParam(m, iter, &show_in_default_list) ||
         !ReadParam(m, iter, &safe_for_autoreplace) ||
         !ReadParam(m, iter, &image_refs_size))
       return false;
 
     *p = TemplateURL();
     for (size_t i = 0; i < image_refs_size; ++i) {
-      std::wstring type;
+      std::string type;
       int width;
       int height;
       GURL url;
       if (!ReadParam(m, iter, &type) ||
           !ReadParam(m, iter, &width) ||
           !ReadParam(m, iter, &height) ||
           !ReadParam(m, iter, &url))
         return false;
       p->add_image_ref(TemplateURL::ImageRef(type, width, height, url));
     }
 
     if (!ReadParam(m, iter, &languages) ||
         !ReadParam(m, iter, &input_encodings) ||
         !ReadParam(m, iter, &date_created) ||
         !ReadParam(m, iter, &usage_count) ||
         !ReadParam(m, iter, &prepopulate_id))
       return false;
 
     p->set_short_name(short_name);
     p->set_description(description);
     p->SetSuggestionsURL(suggestions_url.url(), suggestions_url.index_offset(),
                          suggestions_url.page_offset());
     p->SetURL(url.url(), url.index_offset(), url.page_offset());
     p->set_originating_url(originating_url);
     p->set_keyword(keyword);
     p->set_autogenerate_keyword(autogenerate_keyword);
     p->set_show_in_default_list(show_in_default_list);
     p->set_safe_for_autoreplace(safe_for_autoreplace);
 
-    std::vector<std::wstring>::const_iterator lang_iter;
+    std::vector<string16>::const_iterator lang_iter;
     for (lang_iter = languages.begin();
          lang_iter != languages.end();
          ++lang_iter) {
       p->add_language(*lang_iter);
     }
     p->set_input_encodings(input_encodings);
     p->set_date_created(date_created);
     p->set_usage_count(usage_count);
     p->set_prepopulate_id(prepopulate_id);
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<TemplateURL>");
   }
 };
 
 }  // namespace IPC
 
 #include "chrome/browser/importer/importer_messages_internal.h"
 
 #endif  // CHROME_BROWSER_IMPORTER_IMPORTER_MESSAGES_H_