Refactor Pickle Read methods to use higher performance PickleIterator.

ipc/ipc_message_utils.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.
 
 #ifndef IPC_IPC_MESSAGE_UTILS_H_
 #define IPC_IPC_MESSAGE_UTILS_H_
 #pragma once
 
 #include <algorithm>
 #include <map>
@@ skipping 106 matching lines @@
 
 namespace IPC {
 
 struct ChannelHandle;
 
 //-----------------------------------------------------------------------------
 // An iterator class for reading the fields contained within a Message.
 
 class MessageIterator {
  public:
-  explicit MessageIterator(const Message& m) : msg_(m), iter_(NULL) {
+  explicit MessageIterator(const Message& m) : iter_(m) {
   }
   int NextInt() const {
     int val = -1;
-    if (!msg_.ReadInt(&iter_, &val))
+    if (!iter_.ReadInt(&val))
       NOTREACHED();
     return val;
   }
   const std::string NextString() const {
     std::string val;
-    if (!msg_.ReadString(&iter_, &val))
+    if (!iter_.ReadString(&val))
       NOTREACHED();
     return val;
   }
   const std::wstring NextWString() const {
     std::wstring val;
-    if (!msg_.ReadWString(&iter_, &val))
+    if (!iter_.ReadWString(&val))
       NOTREACHED();
     return val;
   }
   void NextData(const char** data, int* length) const {
-    if (!msg_.ReadData(&iter_, data, length)) {
+    if (!iter_.ReadData(data, length)) {
       NOTREACHED();
     }
   }
  private:
-  const Message& msg_;
-  mutable void* iter_;
+  mutable PickleIterator iter_;
 };
 
 //-----------------------------------------------------------------------------
 // A dummy struct to place first just to allow leading commas for all
 // members in the macro-generated constructor initializer lists.
 struct NoParams {
 };
 
 //-----------------------------------------------------------------------------
 // ParamTraits specializations, etc.
 
 template <class P>
 static inline void WriteParam(Message* m, const P& p) {
   typedef typename SimilarTypeTraits<P>::Type Type;
   ParamTraits<Type>::Write(m, static_cast<const Type& >(p));
 }
 
 template <class P>
-static inline bool WARN_UNUSED_RESULT ReadParam(const Message* m, void** iter,
+static inline bool WARN_UNUSED_RESULT ReadParam(const Message* m,
+                                                PickleIterator* iter,
                                                 P* p) {
   typedef typename SimilarTypeTraits<P>::Type Type;
   return ParamTraits<Type>::Read(m, iter, reinterpret_cast<Type* >(p));
 }
 
 template <class P>
 static inline void LogParam(const P& p, std::string* l) {
   typedef typename SimilarTypeTraits<P>::Type Type;
   ParamTraits<Type>::Log(static_cast<const Type& >(p), l);
 }
 
 template <>
 struct ParamTraits<bool> {
   typedef bool param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteBool(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadBool(iter, r);
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(p ? "true" : "false");
   }
 };
 
 template <>
 struct ParamTraits<int> {
   typedef int param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadInt(iter, r);
   }
   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<unsigned int> {
   typedef unsigned int param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadInt(iter, reinterpret_cast<int*>(r));
   }
   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<long> {
   typedef long param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteLong(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadLong(iter, r);
   }
   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<unsigned long> {
   typedef unsigned long param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteLong(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadLong(iter, reinterpret_cast<long*>(r));
   }
   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<long long> {
   typedef long long param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt64(static_cast<int64>(p));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadInt64(iter, reinterpret_cast<int64*>(r));
   }
   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<unsigned long long> {
   typedef unsigned long long param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt64(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadInt64(iter, reinterpret_cast<int64*>(r));
   }
   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct IPC_EXPORT ParamTraits<unsigned short> {
   typedef unsigned short param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 // Note that the IPC layer doesn't sanitize NaNs and +/- INF values.  Clients
 // should be sure to check the sanity of these values after receiving them over
 // IPC.
 template <>
 struct ParamTraits<float> {
   typedef float param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(param_type));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     const char *data;
     int data_size;
     if (!m->ReadData(iter, &data, &data_size) ||
         data_size != sizeof(param_type)) {
       NOTREACHED();
       return false;
     }
     memcpy(r, data, sizeof(param_type));
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(StringPrintf("%e", p));
   }
 };
 
 template <>
 struct ParamTraits<double> {
   typedef double param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(param_type));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     const char *data;
     int data_size;
     if (!m->ReadData(iter, &data, &data_size) ||
         data_size != sizeof(param_type)) {
       NOTREACHED();
       return false;
     }
     memcpy(r, data, sizeof(param_type));
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(StringPrintf("%e", p));
   }
 };
 
 template <>
 struct IPC_EXPORT ParamTraits<base::Time> {
   typedef base::Time param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct IPC_EXPORT ParamTraits<base::TimeDelta> {
   typedef base::TimeDelta param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct IPC_EXPORT ParamTraits<base::TimeTicks> {
   typedef base::TimeTicks param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 #if defined(OS_WIN)
 template <>
 struct ParamTraits<LOGFONT> {
   typedef LOGFONT param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(LOGFONT));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     const char *data;
     int data_size = 0;
     bool result = m->ReadData(iter, &data, &data_size);
     if (result && data_size == sizeof(LOGFONT)) {
       memcpy(r, data, sizeof(LOGFONT));
     } else {
       result = false;
       NOTREACHED();
     }
 
     return result;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(StringPrintf("<LOGFONT>"));
   }
 };
 
 template <>
 struct ParamTraits<MSG> {
   typedef MSG param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(MSG));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     const char *data;
     int data_size = 0;
     bool result = m->ReadData(iter, &data, &data_size);
     if (result && data_size == sizeof(MSG)) {
       memcpy(r, data, sizeof(MSG));
     } else {
       result = false;
       NOTREACHED();
     }
 
     return result;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<MSG>");
   }
 };
 #endif  // defined(OS_WIN)
 
 template <>
 struct IPC_EXPORT ParamTraits<base::DictionaryValue> {
   typedef base::DictionaryValue param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct IPC_EXPORT ParamTraits<base::ListValue> {
   typedef base::ListValue param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<std::string> {
   typedef std::string param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteString(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadString(iter, r);
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(p);
   }
 };
 
 template<typename CharType>
 static void LogBytes(const std::vector<CharType>& data, std::string* out) {
 #if defined(OS_WIN)
@@ skipping 21 matching lines @@
 struct ParamTraits<std::vector<unsigned char> > {
   typedef std::vector<unsigned char> param_type;
   static void Write(Message* m, const param_type& p) {
     if (p.empty()) {
       m->WriteData(NULL, 0);
     } else {
       m->WriteData(reinterpret_cast<const char*>(&p.front()),
                    static_cast<int>(p.size()));
     }
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     const char *data;
     int data_size = 0;
     if (!m->ReadData(iter, &data, &data_size) || data_size < 0)
       return false;
     r->resize(data_size);
     if (data_size)
       memcpy(&r->front(), data, data_size);
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     LogBytes(p, l);
   }
 };
 
 template <>
 struct ParamTraits<std::vector<char> > {
   typedef std::vector<char> param_type;
   static void Write(Message* m, const param_type& p) {
     if (p.empty()) {
       m->WriteData(NULL, 0);
     } else {
       m->WriteData(&p.front(), static_cast<int>(p.size()));
     }
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     const char *data;
     int data_size = 0;
     if (!m->ReadData(iter, &data, &data_size) || data_size < 0)
       return false;
     r->resize(data_size);
     if (data_size)
       memcpy(&r->front(), data, data_size);
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     LogBytes(p, l);
   }
 };
 
 template <>
 struct ParamTraits<std::vector<bool> > {
   typedef std::vector<bool> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     for (size_t i = 0; i < p.size(); i++)
       WriteParam(m, p[i]);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     int size;
     // ReadLength() checks for < 0 itself.
     if (!m->ReadLength(iter, &size))
       return false;
     r->resize(size);
     for (int i = 0; i < size; i++) {
       bool value;
       if (!ReadParam(m, iter, &value))
         return false;
       (*r)[i] = value;
@@ skipping 10 matching lines @@
 };
 
 template <class P>
 struct ParamTraits<std::vector<P> > {
   typedef std::vector<P> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     for (size_t i = 0; i < p.size(); i++)
       WriteParam(m, p[i]);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     int size;
     // ReadLength() checks for < 0 itself.
     if (!m->ReadLength(iter, &size))
       return false;
     // Resizing beforehand is not safe, see BUG 1006367 for details.
     if (INT_MAX / sizeof(P) <= static_cast<size_t>(size))
       return false;
     r->resize(size);
     for (int i = 0; i < size; i++) {
       if (!ReadParam(m, iter, &(*r)[i]))
@@ skipping 12 matching lines @@
 
 template <class P>
 struct ParamTraits<std::set<P> > {
   typedef std::set<P> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     typename param_type::const_iterator iter;
     for (iter = p.begin(); iter != p.end(); ++iter)
       WriteParam(m, *iter);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     int size;
     if (!m->ReadLength(iter, &size))
       return false;
     for (int i = 0; i < size; ++i) {
       P item;
       if (!ReadParam(m, iter, &item))
         return false;
       r->insert(item);
     }
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<std::set>");
   }
 };
 
 
 template <class K, class V>
 struct ParamTraits<std::map<K, V> > {
   typedef std::map<K, V> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     typename param_type::const_iterator iter;
     for (iter = p.begin(); iter != p.end(); ++iter) {
       WriteParam(m, iter->first);
       WriteParam(m, iter->second);
     }
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     int size;
     if (!ReadParam(m, iter, &size) || size < 0)
       return false;
     for (int i = 0; i < size; ++i) {
       K k;
       if (!ReadParam(m, iter, &k))
         return false;
       V& value = (*r)[k];
       if (!ReadParam(m, iter, &value))
         return false;
     }
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<std::map>");
   }
 };
 
 
 template <>
 struct ParamTraits<std::wstring> {
   typedef std::wstring param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteWString(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadWString(iter, r);
   }
   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <class A, class B>
 struct ParamTraits<std::pair<A, B> > {
   typedef std::pair<A, B> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.first);
     WriteParam(m, p.second);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return ReadParam(m, iter, &r->first) && ReadParam(m, iter, &r->second);
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("(");
     LogParam(p.first, l);
     l->append(", ");
     LogParam(p.second, l);
     l->append(")");
   }
 };
 
 template <>
 struct IPC_EXPORT ParamTraits<NullableString16> {
   typedef NullableString16 param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 // If WCHAR_T_IS_UTF16 is defined, then string16 is a std::wstring so we don't
 // need this trait.
 #if !defined(WCHAR_T_IS_UTF16)
 template <>
 struct ParamTraits<string16> {
   typedef string16 param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteString16(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     return m->ReadString16(iter, r);
   }
   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 #endif
 
 // and, a few more useful types...
 #if defined(OS_WIN)
 template <>
 struct ParamTraits<HANDLE> {
   typedef HANDLE param_type;
   static void Write(Message* m, const param_type& p) {
     // Note that HWNDs/HANDLE/HCURSOR/HACCEL etc are always 32 bits, even on 64
     // bit systems.
     m->WriteUInt32(reinterpret_cast<uint32>(p));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter,
+                   param_type* r) {
     DCHECK_EQ(sizeof(param_type), sizeof(uint32));
     return m->ReadUInt32(iter, reinterpret_cast<uint32*>(r));
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(StringPrintf("0x%X", p));
   }
 };
 
 template <>
 struct ParamTraits<HCURSOR> {
   typedef HCURSOR param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteUInt32(reinterpret_cast<uint32>(p));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     DCHECK_EQ(sizeof(param_type), sizeof(uint32));
     return m->ReadUInt32(iter, reinterpret_cast<uint32*>(r));
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(StringPrintf("0x%X", p));
   }
 };
 
 template <>
 struct ParamTraits<HACCEL> {
   typedef HACCEL param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteUInt32(reinterpret_cast<uint32>(p));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     DCHECK_EQ(sizeof(param_type), sizeof(uint32));
     return m->ReadUInt32(iter, reinterpret_cast<uint32*>(r));
   }
 };
 
 template <>
 struct ParamTraits<POINT> {
   typedef POINT param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt(p.x);
     m->WriteInt(p.y);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     int x, y;
     if (!m->ReadInt(iter, &x) || !m->ReadInt(iter, &y))
       return false;
     r->x = x;
     r->y = y;
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(StringPrintf("(%d, %d)", p.x, p.y));
   }
 };
 #endif  // defined(OS_WIN)
 
 template <>
 struct IPC_EXPORT ParamTraits<FilePath> {
   typedef FilePath param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 #if defined(OS_POSIX)
 // FileDescriptors may be serialised over IPC channels on POSIX. On the
 // receiving side, the FileDescriptor is a valid duplicate of the file
 // descriptor which was transmitted: *it is not just a copy of the integer like
 // HANDLEs on Windows*. The only exception is if the file descriptor is < 0. In
 // this case, the receiving end will see a value of -1. *Zero is a valid file
 // descriptor*.
 //
 // The received file descriptor will have the |auto_close| flag set to true. The
 // code which handles the message is responsible for taking ownership of it.
 // File descriptors are OS resources and must be closed when no longer needed.
 //
 // When sending a file descriptor, the file descriptor must be valid at the time
 // of transmission. Since transmission is not synchronous, one should consider
 // dup()ing any file descriptors to be transmitted and setting the |auto_close|
 // flag, which causes the file descriptor to be closed after writing.
 template<>
 struct IPC_EXPORT ParamTraits<base::FileDescriptor> {
   typedef base::FileDescriptor param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 #endif  // defined(OS_POSIX)
 
 // A ChannelHandle is basically a platform-inspecific wrapper around the
 // fact that IPC endpoints are handled specially on POSIX.  See above comments
 // on FileDescriptor for more background.
 template<>
 struct IPC_EXPORT ParamTraits<IPC::ChannelHandle> {
   typedef ChannelHandle param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 #if defined(OS_WIN)
 template <>
 struct ParamTraits<XFORM> {
   typedef XFORM param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(XFORM));
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     const char *data;
     int data_size = 0;
     bool result = m->ReadData(iter, &data, &data_size);
     if (result && data_size == sizeof(XFORM)) {
       memcpy(r, data, sizeof(XFORM));
     } else {
       result = false;
       NOTREACHED();
     }
 
@@ skipping 19 matching lines @@
   int64 dispatch;  // Time after it was dispatched (i.e. after calling
                    // OnMessageReceived).
   std::string message_name;
   std::string params;
 };
 
 template <>
 struct IPC_EXPORT ParamTraits<LogData> {
   typedef LogData param_type;
   static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* r);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l) {
     // Doesn't make sense to implement this!
   }
 };
 
 template <>
 struct ParamTraits<Message> {
   static void Write(Message* m, const Message& p) {
     DCHECK(p.size() <= INT_MAX);
     int message_size = static_cast<int>(p.size());
     m->WriteInt(message_size);
     m->WriteData(reinterpret_cast<const char*>(p.data()), message_size);
   }
-  static bool Read(const Message* m, void** iter, Message* r) {
+  static bool Read(const Message* m, PickleIterator* iter, Message* r) {
     int size;
     if (!m->ReadInt(iter, &size))
       return false;
     const char* data;
     if (!m->ReadData(iter, &data, &size))
       return false;
     *r = Message(data, size);
     return true;
   }
   static void Log(const Message& p, std::string* l) {
     l->append("<IPC::Message>");
   }
 };
 
 template <>
 struct ParamTraits<Tuple0> {
   typedef Tuple0 param_type;
   static void Write(Message* m, const param_type& p) {
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
   }
 };
 
 template <class A>
 struct ParamTraits< Tuple1<A> > {
   typedef Tuple1<A> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.a);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     return ReadParam(m, iter, &r->a);
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(p.a, l);
   }
 };
 
 template <class A, class B>
 struct ParamTraits< Tuple2<A, B> > {
   typedef Tuple2<A, B> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.a);
     WriteParam(m, p.b);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     return (ReadParam(m, iter, &r->a) &&
             ReadParam(m, iter, &r->b));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(p.a, l);
     l->append(", ");
     LogParam(p.b, l);
   }
 };
 
 template <class A, class B, class C>
 struct ParamTraits< Tuple3<A, B, C> > {
   typedef Tuple3<A, B, C> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.a);
     WriteParam(m, p.b);
     WriteParam(m, p.c);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     return (ReadParam(m, iter, &r->a) &&
             ReadParam(m, iter, &r->b) &&
             ReadParam(m, iter, &r->c));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(p.a, l);
     l->append(", ");
     LogParam(p.b, l);
     l->append(", ");
     LogParam(p.c, l);
   }
 };
 
 template <class A, class B, class C, class D>
 struct ParamTraits< Tuple4<A, B, C, D> > {
   typedef Tuple4<A, B, C, D> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.a);
     WriteParam(m, p.b);
     WriteParam(m, p.c);
     WriteParam(m, p.d);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     return (ReadParam(m, iter, &r->a) &&
             ReadParam(m, iter, &r->b) &&
             ReadParam(m, iter, &r->c) &&
             ReadParam(m, iter, &r->d));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(p.a, l);
     l->append(", ");
     LogParam(p.b, l);
     l->append(", ");
     LogParam(p.c, l);
     l->append(", ");
     LogParam(p.d, l);
   }
 };
 
 template <class A, class B, class C, class D, class E>
 struct ParamTraits< Tuple5<A, B, C, D, E> > {
   typedef Tuple5<A, B, C, D, E> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.a);
     WriteParam(m, p.b);
     WriteParam(m, p.c);
     WriteParam(m, p.d);
     WriteParam(m, p.e);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
     return (ReadParam(m, iter, &r->a) &&
             ReadParam(m, iter, &r->b) &&
             ReadParam(m, iter, &r->c) &&
             ReadParam(m, iter, &r->d) &&
             ReadParam(m, iter, &r->e));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(p.a, l);
     l->append(", ");
     LogParam(p.b, l);
@@ skipping 67 matching lines @@
 #endif
 
 // This class assumes that its template argument is a RefTuple (a Tuple with
 // reference elements). This would go into ipc_message_utils_impl.h, but it is
 // also used by chrome_frame.
 template <class RefTuple>
 class ParamDeserializer : public MessageReplyDeserializer {
  public:
   explicit ParamDeserializer(const RefTuple& out) : out_(out) { }
 
-  bool SerializeOutputParameters(const IPC::Message& msg, void* iter) {
+  bool SerializeOutputParameters(const IPC::Message& msg, PickleIterator iter) {
     return ReadParam(&msg, &iter, &out_);
   }
 
   RefTuple out_;
 };
 
 // Used for synchronous messages.
 template <class SendParamType, class ReplyParamType>
 class SyncMessageSchema {
  public:
@@ skipping 72 matching lines @@
     ReplyParam p(a, b, c, d, e);
     WriteParam(reply, p);
   }
 };
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_MESSAGE_UTILS_H_