Refactor Pickle Read methods to use higher performance PickleIterator.

chrome/browser/importer/profile_import_process_messages.h

 // Copyright (c) 2012 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.
 
 // Multiply-included message file, no traditonal include guard.
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/string16.h"
@@ skipping 17 matching lines @@
 template <>
 struct ParamTraits<importer::SourceProfile> {
   typedef importer::SourceProfile param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.importer_name);
     WriteParam(m, static_cast<int>(p.importer_type));
     WriteParam(m, p.source_path);
     WriteParam(m, p.app_path);
     WriteParam(m, static_cast<int>(p.services_supported));
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
     if (!ReadParam(m, iter, &p->importer_name))
       return false;
 
     int importer_type = 0;
     if (!ReadParam(m, iter, &importer_type))
       return false;
     p->importer_type = static_cast<importer::ImporterType>(importer_type);
 
     if (!ReadParam(m, iter, &p->source_path) ||
         !ReadParam(m, iter, &p->app_path))
@@ skipping 27 matching lines @@
   typedef history::URLRow param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.id());
     WriteParam(m, p.url());
     WriteParam(m, p.title());
     WriteParam(m, p.visit_count());
     WriteParam(m, p.typed_count());
     WriteParam(m, p.last_visit());
     WriteParam(m, p.hidden());
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
     history::URLID id;
     GURL url;
     string16 title;
     int visit_count, typed_count;
     base::Time last_visit;
     bool hidden;
     if (!ReadParam(m, iter, &id) ||
         !ReadParam(m, iter, &url) ||
         !ReadParam(m, iter, &title) ||
         !ReadParam(m, iter, &visit_count) ||
@@ skipping 33 matching lines @@
 struct ParamTraits<ProfileWriter::BookmarkEntry> {
   typedef ProfileWriter::BookmarkEntry param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.in_toolbar);
     WriteParam(m, p.is_folder);
     WriteParam(m, p.url);
     WriteParam(m, p.path);
     WriteParam(m, p.title);
     WriteParam(m, p.creation_time);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
     return
         (ReadParam(m, iter, &p->in_toolbar)) &&
         (ReadParam(m, iter, &p->is_folder)) &&
         (ReadParam(m, iter, &p->url)) &&
         (ReadParam(m, iter, &p->path)) &&
         (ReadParam(m, iter, &p->title)) &&
         (ReadParam(m, iter, &p->creation_time));
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("(");
@@ skipping 14 matching lines @@
 
 // Traits for history::ImportedFaviconUsage.
 template <>
 struct ParamTraits<history::ImportedFaviconUsage> {
   typedef history::ImportedFaviconUsage param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.favicon_url);
     WriteParam(m, p.png_data);
     WriteParam(m, p.urls);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
     return
         ReadParam(m, iter, &p->favicon_url) &&
         ReadParam(m, iter, &p->png_data) &&
         ReadParam(m, iter, &p->urls);
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("(");
     LogParam(p.favicon_url, l);
     l->append(", ");
     LogParam(p.png_data, l);
     l->append(", ");
     LogParam(p.urls, l);
     l->append(")");
   }
 };  // ParamTraits<history::ImportedFaviconUsage
 
 // Traits for TemplateURLRef
 template <>
 struct ParamTraits<TemplateURLRef> {
   typedef TemplateURLRef param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.url());
     WriteParam(m, p.index_offset());
     WriteParam(m, p.page_offset());
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
     std::string url;
     int index_offset;
     int page_offset;
     if (!ReadParam(m, iter, &url) ||
         !ReadParam(m, iter, &index_offset) ||
         !ReadParam(m, iter, &page_offset))
       return false;
     *p = TemplateURLRef(url, index_offset, page_offset);
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<TemplateURLRef>");
   }
 };
 
 // Traits for TemplateURL::ImageRef
 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) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
     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
@@ skipping 33 matching lines @@
       WriteParam(m, iter->url);
     }
 
     WriteParam(m, p.languages());
     WriteParam(m, p.input_encodings());
     WriteParam(m, p.date_created());
     WriteParam(m, p.last_modified());
     WriteParam(m, p.usage_count());
     WriteParam(m, p.prepopulate_id());
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
     string16 short_name;
     string16 description;
     bool includes_suggestions_url;
     TemplateURLRef suggestions_url;
     TemplateURLRef url;
     GURL originating_url;
     string16 keyword;
     bool autogenerate_keyword;
     bool show_in_default_list;
     bool safe_for_autoreplace;
@@ skipping 138 matching lines @@
 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFaviconsImportGroup,
                      std::vector<history::ImportedFaviconUsage>)
 
 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyPasswordFormReady,
                      webkit::forms::PasswordForm)
 
 IPC_MESSAGE_CONTROL3(ProfileImportProcessHostMsg_NotifyKeywordsReady,
                      std::vector<TemplateURL>,
                      int,  /* default keyword index */
                      bool  /* unique on host and path */)