Home | History | Annotate | Download | only in ipc 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef IPC_IPC_MESSAGE_UTILS_H_
      6 #define IPC_IPC_MESSAGE_UTILS_H_
      7 
      8 #include <algorithm>
      9 #include <map>
     10 #include <set>
     11 #include <string>
     12 #include <vector>
     13 
     14 #include "base/format_macros.h"
     15 #include "base/memory/scoped_vector.h"
     16 #include "base/platform_file.h"
     17 #include "base/strings/string16.h"
     18 #include "base/strings/string_util.h"
     19 #include "base/strings/stringprintf.h"
     20 #include "base/tuple.h"
     21 #include "ipc/ipc_message_start.h"
     22 #include "ipc/ipc_param_traits.h"
     23 #include "ipc/ipc_sync_message.h"
     24 
     25 #if defined(COMPILER_GCC)
     26 // GCC "helpfully" tries to inline template methods in release mode. Except we
     27 // want the majority of the template junk being expanded once in the
     28 // implementation file (and only provide the definitions in
     29 // ipc_message_utils_impl.h in those files) and exported, instead of expanded
     30 // at every call site. Special note: GCC happily accepts the attribute before
     31 // the method declaration, but only acts on it if it is after.
     32 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40500
     33 // Starting in gcc 4.5, the noinline no longer implies the concept covered by
     34 // the introduced noclone attribute, which will create specialized versions of
     35 // functions/methods when certain types are constant.
     36 // www.gnu.org/software/gcc/gcc-4.5/changes.html
     37 #define IPC_MSG_NOINLINE  __attribute__((noinline, noclone));
     38 #else
     39 #define IPC_MSG_NOINLINE  __attribute__((noinline));
     40 #endif
     41 #elif defined(COMPILER_MSVC)
     42 // MSVC++ doesn't do this.
     43 #define IPC_MSG_NOINLINE
     44 #else
     45 #error "Please add the noinline property for your new compiler here."
     46 #endif
     47 
     48 namespace base {
     49 class DictionaryValue;
     50 class FilePath;
     51 class ListValue;
     52 class NullableString16;
     53 class Time;
     54 class TimeDelta;
     55 class TimeTicks;
     56 struct FileDescriptor;
     57 }
     58 
     59 namespace IPC {
     60 
     61 struct ChannelHandle;
     62 
     63 // -----------------------------------------------------------------------------
     64 // How we send IPC message logs across channels.
     65 struct IPC_EXPORT LogData {
     66   LogData();
     67   ~LogData();
     68 
     69   std::string channel;
     70   int32 routing_id;
     71   uint32 type;  // "User-defined" message type, from ipc_message.h.
     72   std::string flags;
     73   int64 sent;  // Time that the message was sent (i.e. at Send()).
     74   int64 receive;  // Time before it was dispatched (i.e. before calling
     75                   // OnMessageReceived).
     76   int64 dispatch;  // Time after it was dispatched (i.e. after calling
     77                    // OnMessageReceived).
     78   std::string message_name;
     79   std::string params;
     80 };
     81 
     82 //-----------------------------------------------------------------------------
     83 
     84 // A dummy struct to place first just to allow leading commas for all
     85 // members in the macro-generated constructor initializer lists.
     86 struct NoParams {
     87 };
     88 
     89 template <class P>
     90 static inline void WriteParam(Message* m, const P& p) {
     91   typedef typename SimilarTypeTraits<P>::Type Type;
     92   ParamTraits<Type>::Write(m, static_cast<const Type& >(p));
     93 }
     94 
     95 template <class P>
     96 static inline bool WARN_UNUSED_RESULT ReadParam(const Message* m,
     97                                                 PickleIterator* iter,
     98                                                 P* p) {
     99   typedef typename SimilarTypeTraits<P>::Type Type;
    100   return ParamTraits<Type>::Read(m, iter, reinterpret_cast<Type* >(p));
    101 }
    102 
    103 template <class P>
    104 static inline void LogParam(const P& p, std::string* l) {
    105   typedef typename SimilarTypeTraits<P>::Type Type;
    106   ParamTraits<Type>::Log(static_cast<const Type& >(p), l);
    107 }
    108 
    109 // Primitive ParamTraits -------------------------------------------------------
    110 
    111 template <>
    112 struct ParamTraits<bool> {
    113   typedef bool param_type;
    114   static void Write(Message* m, const param_type& p) {
    115     m->WriteBool(p);
    116   }
    117   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    118     return m->ReadBool(iter, r);
    119   }
    120   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    121 };
    122 
    123 template <>
    124 struct IPC_EXPORT ParamTraits<unsigned char> {
    125   typedef unsigned char param_type;
    126   static void Write(Message* m, const param_type& p);
    127   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    128   static void Log(const param_type& p, std::string* l);
    129 };
    130 
    131 template <>
    132 struct IPC_EXPORT ParamTraits<unsigned short> {
    133   typedef unsigned short param_type;
    134   static void Write(Message* m, const param_type& p);
    135   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    136   static void Log(const param_type& p, std::string* l);
    137 };
    138 
    139 template <>
    140 struct ParamTraits<int> {
    141   typedef int param_type;
    142   static void Write(Message* m, const param_type& p) {
    143     m->WriteInt(p);
    144   }
    145   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    146     return m->ReadInt(iter, r);
    147   }
    148   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    149 };
    150 
    151 template <>
    152 struct ParamTraits<unsigned int> {
    153   typedef unsigned int param_type;
    154   static void Write(Message* m, const param_type& p) {
    155     m->WriteInt(p);
    156   }
    157   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    158     return m->ReadInt(iter, reinterpret_cast<int*>(r));
    159   }
    160   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    161 };
    162 
    163 template <>
    164 struct ParamTraits<long> {
    165   typedef long param_type;
    166   static void Write(Message* m, const param_type& p) {
    167     m->WriteLongUsingDangerousNonPortableLessPersistableForm(p);
    168   }
    169   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    170     return m->ReadLong(iter, r);
    171   }
    172   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    173 };
    174 
    175 template <>
    176 struct ParamTraits<unsigned long> {
    177   typedef unsigned long param_type;
    178   static void Write(Message* m, const param_type& p) {
    179     m->WriteLongUsingDangerousNonPortableLessPersistableForm(p);
    180   }
    181   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    182     return m->ReadLong(iter, reinterpret_cast<long*>(r));
    183   }
    184   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    185 };
    186 
    187 template <>
    188 struct ParamTraits<long long> {
    189   typedef long long param_type;
    190   static void Write(Message* m, const param_type& p) {
    191     m->WriteInt64(static_cast<int64>(p));
    192   }
    193   static bool Read(const Message* m, PickleIterator* iter,
    194                    param_type* r) {
    195     return m->ReadInt64(iter, reinterpret_cast<int64*>(r));
    196   }
    197   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    198 };
    199 
    200 template <>
    201 struct ParamTraits<unsigned long long> {
    202   typedef unsigned long long param_type;
    203   static void Write(Message* m, const param_type& p) {
    204     m->WriteInt64(p);
    205   }
    206   static bool Read(const Message* m, PickleIterator* iter,
    207                    param_type* r) {
    208     return m->ReadInt64(iter, reinterpret_cast<int64*>(r));
    209   }
    210   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    211 };
    212 
    213 // Note that the IPC layer doesn't sanitize NaNs and +/- INF values.  Clients
    214 // should be sure to check the sanity of these values after receiving them over
    215 // IPC.
    216 template <>
    217 struct IPC_EXPORT ParamTraits<float> {
    218   typedef float param_type;
    219   static void Write(Message* m, const param_type& p) {
    220     m->WriteFloat(p);
    221   }
    222   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    223     return m->ReadFloat(iter, r);
    224   }
    225   static void Log(const param_type& p, std::string* l);
    226 };
    227 
    228 template <>
    229 struct IPC_EXPORT ParamTraits<double> {
    230   typedef double param_type;
    231   static void Write(Message* m, const param_type& p);
    232   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    233   static void Log(const param_type& p, std::string* l);
    234 };
    235 
    236 // STL ParamTraits -------------------------------------------------------------
    237 
    238 template <>
    239 struct ParamTraits<std::string> {
    240   typedef std::string param_type;
    241   static void Write(Message* m, const param_type& p) {
    242     m->WriteString(p);
    243   }
    244   static bool Read(const Message* m, PickleIterator* iter,
    245                    param_type* r) {
    246     return m->ReadString(iter, r);
    247   }
    248   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    249 };
    250 
    251 template <>
    252 struct ParamTraits<std::wstring> {
    253   typedef std::wstring param_type;
    254   static void Write(Message* m, const param_type& p) {
    255     m->WriteWString(p);
    256   }
    257   static bool Read(const Message* m, PickleIterator* iter,
    258                    param_type* r) {
    259     return m->ReadWString(iter, r);
    260   }
    261   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    262 };
    263 
    264 // If WCHAR_T_IS_UTF16 is defined, then string16 is a std::wstring so we don't
    265 // need this trait.
    266 #if !defined(WCHAR_T_IS_UTF16)
    267 template <>
    268 struct ParamTraits<base::string16> {
    269   typedef base::string16 param_type;
    270   static void Write(Message* m, const param_type& p) {
    271     m->WriteString16(p);
    272   }
    273   static bool Read(const Message* m, PickleIterator* iter,
    274                    param_type* r) {
    275     return m->ReadString16(iter, r);
    276   }
    277   IPC_EXPORT static void Log(const param_type& p, std::string* l);
    278 };
    279 #endif
    280 
    281 template <>
    282 struct IPC_EXPORT ParamTraits<std::vector<char> > {
    283   typedef std::vector<char> param_type;
    284   static void Write(Message* m, const param_type& p);
    285   static bool Read(const Message*, PickleIterator* iter, param_type* r);
    286   static void Log(const param_type& p, std::string* l);
    287 };
    288 
    289 template <>
    290 struct IPC_EXPORT ParamTraits<std::vector<unsigned char> > {
    291   typedef std::vector<unsigned char> param_type;
    292   static void Write(Message* m, const param_type& p);
    293   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    294   static void Log(const param_type& p, std::string* l);
    295 };
    296 
    297 template <>
    298 struct IPC_EXPORT ParamTraits<std::vector<bool> > {
    299   typedef std::vector<bool> param_type;
    300   static void Write(Message* m, const param_type& p);
    301   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    302   static void Log(const param_type& p, std::string* l);
    303 };
    304 
    305 template <class P>
    306 struct ParamTraits<std::vector<P> > {
    307   typedef std::vector<P> param_type;
    308   static void Write(Message* m, const param_type& p) {
    309     WriteParam(m, static_cast<int>(p.size()));
    310     for (size_t i = 0; i < p.size(); i++)
    311       WriteParam(m, p[i]);
    312   }
    313   static bool Read(const Message* m, PickleIterator* iter,
    314                    param_type* r) {
    315     int size;
    316     // ReadLength() checks for < 0 itself.
    317     if (!m->ReadLength(iter, &size))
    318       return false;
    319     // Resizing beforehand is not safe, see BUG 1006367 for details.
    320     if (INT_MAX / sizeof(P) <= static_cast<size_t>(size))
    321       return false;
    322     r->resize(size);
    323     for (int i = 0; i < size; i++) {
    324       if (!ReadParam(m, iter, &(*r)[i]))
    325         return false;
    326     }
    327     return true;
    328   }
    329   static void Log(const param_type& p, std::string* l) {
    330     for (size_t i = 0; i < p.size(); ++i) {
    331       if (i != 0)
    332         l->append(" ");
    333       LogParam((p[i]), l);
    334     }
    335   }
    336 };
    337 
    338 template <class P>
    339 struct ParamTraits<std::set<P> > {
    340   typedef std::set<P> param_type;
    341   static void Write(Message* m, const param_type& p) {
    342     WriteParam(m, static_cast<int>(p.size()));
    343     typename param_type::const_iterator iter;
    344     for (iter = p.begin(); iter != p.end(); ++iter)
    345       WriteParam(m, *iter);
    346   }
    347   static bool Read(const Message* m, PickleIterator* iter,
    348                    param_type* r) {
    349     int size;
    350     if (!m->ReadLength(iter, &size))
    351       return false;
    352     for (int i = 0; i < size; ++i) {
    353       P item;
    354       if (!ReadParam(m, iter, &item))
    355         return false;
    356       r->insert(item);
    357     }
    358     return true;
    359   }
    360   static void Log(const param_type& p, std::string* l) {
    361     l->append("<std::set>");
    362   }
    363 };
    364 
    365 template <class K, class V>
    366 struct ParamTraits<std::map<K, V> > {
    367   typedef std::map<K, V> param_type;
    368   static void Write(Message* m, const param_type& p) {
    369     WriteParam(m, static_cast<int>(p.size()));
    370     typename param_type::const_iterator iter;
    371     for (iter = p.begin(); iter != p.end(); ++iter) {
    372       WriteParam(m, iter->first);
    373       WriteParam(m, iter->second);
    374     }
    375   }
    376   static bool Read(const Message* m, PickleIterator* iter,
    377                    param_type* r) {
    378     int size;
    379     if (!ReadParam(m, iter, &size) || size < 0)
    380       return false;
    381     for (int i = 0; i < size; ++i) {
    382       K k;
    383       if (!ReadParam(m, iter, &k))
    384         return false;
    385       V& value = (*r)[k];
    386       if (!ReadParam(m, iter, &value))
    387         return false;
    388     }
    389     return true;
    390   }
    391   static void Log(const param_type& p, std::string* l) {
    392     l->append("<std::map>");
    393   }
    394 };
    395 
    396 template <class A, class B>
    397 struct ParamTraits<std::pair<A, B> > {
    398   typedef std::pair<A, B> param_type;
    399   static void Write(Message* m, const param_type& p) {
    400     WriteParam(m, p.first);
    401     WriteParam(m, p.second);
    402   }
    403   static bool Read(const Message* m, PickleIterator* iter,
    404                    param_type* r) {
    405     return ReadParam(m, iter, &r->first) && ReadParam(m, iter, &r->second);
    406   }
    407   static void Log(const param_type& p, std::string* l) {
    408     l->append("(");
    409     LogParam(p.first, l);
    410     l->append(", ");
    411     LogParam(p.second, l);
    412     l->append(")");
    413   }
    414 };
    415 
    416 // Base ParamTraits ------------------------------------------------------------
    417 
    418 template <>
    419 struct IPC_EXPORT ParamTraits<base::DictionaryValue> {
    420   typedef base::DictionaryValue param_type;
    421   static void Write(Message* m, const param_type& p);
    422   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    423   static void Log(const param_type& p, std::string* l);
    424 };
    425 
    426 #if defined(OS_POSIX)
    427 // FileDescriptors may be serialised over IPC channels on POSIX. On the
    428 // receiving side, the FileDescriptor is a valid duplicate of the file
    429 // descriptor which was transmitted: *it is not just a copy of the integer like
    430 // HANDLEs on Windows*. The only exception is if the file descriptor is < 0. In
    431 // this case, the receiving end will see a value of -1. *Zero is a valid file
    432 // descriptor*.
    433 //
    434 // The received file descriptor will have the |auto_close| flag set to true. The
    435 // code which handles the message is responsible for taking ownership of it.
    436 // File descriptors are OS resources and must be closed when no longer needed.
    437 //
    438 // When sending a file descriptor, the file descriptor must be valid at the time
    439 // of transmission. Since transmission is not synchronous, one should consider
    440 // dup()ing any file descriptors to be transmitted and setting the |auto_close|
    441 // flag, which causes the file descriptor to be closed after writing.
    442 template<>
    443 struct IPC_EXPORT ParamTraits<base::FileDescriptor> {
    444   typedef base::FileDescriptor param_type;
    445   static void Write(Message* m, const param_type& p);
    446   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    447   static void Log(const param_type& p, std::string* l);
    448 };
    449 #endif  // defined(OS_POSIX)
    450 
    451 template <>
    452 struct IPC_EXPORT ParamTraits<base::FilePath> {
    453   typedef base::FilePath param_type;
    454   static void Write(Message* m, const param_type& p);
    455   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    456   static void Log(const param_type& p, std::string* l);
    457 };
    458 
    459 template <>
    460 struct IPC_EXPORT ParamTraits<base::ListValue> {
    461   typedef base::ListValue param_type;
    462   static void Write(Message* m, const param_type& p);
    463   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    464   static void Log(const param_type& p, std::string* l);
    465 };
    466 
    467 template <>
    468 struct IPC_EXPORT ParamTraits<base::NullableString16> {
    469   typedef base::NullableString16 param_type;
    470   static void Write(Message* m, const param_type& p);
    471   static bool Read(const Message* m, PickleIterator* iter,
    472                    param_type* r);
    473   static void Log(const param_type& p, std::string* l);
    474 };
    475 
    476 template <>
    477 struct IPC_EXPORT ParamTraits<base::PlatformFileInfo> {
    478   typedef base::PlatformFileInfo param_type;
    479   static void Write(Message* m, const param_type& p);
    480   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    481   static void Log(const param_type& p, std::string* l);
    482 };
    483 
    484 template <>
    485 struct SimilarTypeTraits<base::PlatformFileError> {
    486   typedef int Type;
    487 };
    488 
    489 #if defined(OS_WIN)
    490 template <>
    491 struct SimilarTypeTraits<HWND> {
    492   typedef HANDLE Type;
    493 };
    494 #endif  // defined(OS_WIN)
    495 
    496 template <>
    497 struct IPC_EXPORT ParamTraits<base::Time> {
    498   typedef base::Time param_type;
    499   static void Write(Message* m, const param_type& p);
    500   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    501   static void Log(const param_type& p, std::string* l);
    502 };
    503 
    504 template <>
    505 struct IPC_EXPORT ParamTraits<base::TimeDelta> {
    506   typedef base::TimeDelta param_type;
    507   static void Write(Message* m, const param_type& p);
    508   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    509   static void Log(const param_type& p, std::string* l);
    510 };
    511 
    512 template <>
    513 struct IPC_EXPORT ParamTraits<base::TimeTicks> {
    514   typedef base::TimeTicks param_type;
    515   static void Write(Message* m, const param_type& p);
    516   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    517   static void Log(const param_type& p, std::string* l);
    518 };
    519 
    520 template <>
    521 struct ParamTraits<Tuple0> {
    522   typedef Tuple0 param_type;
    523   static void Write(Message* m, const param_type& p) {
    524   }
    525   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    526     return true;
    527   }
    528   static void Log(const param_type& p, std::string* l) {
    529   }
    530 };
    531 
    532 template <class A>
    533 struct ParamTraits< Tuple1<A> > {
    534   typedef Tuple1<A> param_type;
    535   static void Write(Message* m, const param_type& p) {
    536     WriteParam(m, p.a);
    537   }
    538   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    539     return ReadParam(m, iter, &r->a);
    540   }
    541   static void Log(const param_type& p, std::string* l) {
    542     LogParam(p.a, l);
    543   }
    544 };
    545 
    546 template <class A, class B>
    547 struct ParamTraits< Tuple2<A, B> > {
    548   typedef Tuple2<A, B> param_type;
    549   static void Write(Message* m, const param_type& p) {
    550     WriteParam(m, p.a);
    551     WriteParam(m, p.b);
    552   }
    553   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    554     return (ReadParam(m, iter, &r->a) &&
    555             ReadParam(m, iter, &r->b));
    556   }
    557   static void Log(const param_type& p, std::string* l) {
    558     LogParam(p.a, l);
    559     l->append(", ");
    560     LogParam(p.b, l);
    561   }
    562 };
    563 
    564 template <class A, class B, class C>
    565 struct ParamTraits< Tuple3<A, B, C> > {
    566   typedef Tuple3<A, B, C> param_type;
    567   static void Write(Message* m, const param_type& p) {
    568     WriteParam(m, p.a);
    569     WriteParam(m, p.b);
    570     WriteParam(m, p.c);
    571   }
    572   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    573     return (ReadParam(m, iter, &r->a) &&
    574             ReadParam(m, iter, &r->b) &&
    575             ReadParam(m, iter, &r->c));
    576   }
    577   static void Log(const param_type& p, std::string* l) {
    578     LogParam(p.a, l);
    579     l->append(", ");
    580     LogParam(p.b, l);
    581     l->append(", ");
    582     LogParam(p.c, l);
    583   }
    584 };
    585 
    586 template <class A, class B, class C, class D>
    587 struct ParamTraits< Tuple4<A, B, C, D> > {
    588   typedef Tuple4<A, B, C, D> param_type;
    589   static void Write(Message* m, const param_type& p) {
    590     WriteParam(m, p.a);
    591     WriteParam(m, p.b);
    592     WriteParam(m, p.c);
    593     WriteParam(m, p.d);
    594   }
    595   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    596     return (ReadParam(m, iter, &r->a) &&
    597             ReadParam(m, iter, &r->b) &&
    598             ReadParam(m, iter, &r->c) &&
    599             ReadParam(m, iter, &r->d));
    600   }
    601   static void Log(const param_type& p, std::string* l) {
    602     LogParam(p.a, l);
    603     l->append(", ");
    604     LogParam(p.b, l);
    605     l->append(", ");
    606     LogParam(p.c, l);
    607     l->append(", ");
    608     LogParam(p.d, l);
    609   }
    610 };
    611 
    612 template <class A, class B, class C, class D, class E>
    613 struct ParamTraits< Tuple5<A, B, C, D, E> > {
    614   typedef Tuple5<A, B, C, D, E> param_type;
    615   static void Write(Message* m, const param_type& p) {
    616     WriteParam(m, p.a);
    617     WriteParam(m, p.b);
    618     WriteParam(m, p.c);
    619     WriteParam(m, p.d);
    620     WriteParam(m, p.e);
    621   }
    622   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    623     return (ReadParam(m, iter, &r->a) &&
    624             ReadParam(m, iter, &r->b) &&
    625             ReadParam(m, iter, &r->c) &&
    626             ReadParam(m, iter, &r->d) &&
    627             ReadParam(m, iter, &r->e));
    628   }
    629   static void Log(const param_type& p, std::string* l) {
    630     LogParam(p.a, l);
    631     l->append(", ");
    632     LogParam(p.b, l);
    633     l->append(", ");
    634     LogParam(p.c, l);
    635     l->append(", ");
    636     LogParam(p.d, l);
    637     l->append(", ");
    638     LogParam(p.e, l);
    639   }
    640 };
    641 
    642 template<class P>
    643 struct ParamTraits<ScopedVector<P> > {
    644   typedef ScopedVector<P> param_type;
    645   static void Write(Message* m, const param_type& p) {
    646     WriteParam(m, static_cast<int>(p.size()));
    647     for (size_t i = 0; i < p.size(); i++)
    648       WriteParam(m, *p[i]);
    649   }
    650   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
    651     int size = 0;
    652     if (!m->ReadLength(iter, &size))
    653       return false;
    654     if (INT_MAX/sizeof(P) <= static_cast<size_t>(size))
    655       return false;
    656     r->resize(size);
    657     for (int i = 0; i < size; i++) {
    658       (*r)[i] = new P();
    659       if (!ReadParam(m, iter, (*r)[i]))
    660         return false;
    661     }
    662     return true;
    663   }
    664   static void Log(const param_type& p, std::string* l) {
    665     for (size_t i = 0; i < p.size(); ++i) {
    666       if (i != 0)
    667         l->append(" ");
    668       LogParam(*p[i], l);
    669     }
    670   }
    671 };
    672 
    673 // IPC types ParamTraits -------------------------------------------------------
    674 
    675 // A ChannelHandle is basically a platform-inspecific wrapper around the
    676 // fact that IPC endpoints are handled specially on POSIX.  See above comments
    677 // on FileDescriptor for more background.
    678 template<>
    679 struct IPC_EXPORT ParamTraits<IPC::ChannelHandle> {
    680   typedef ChannelHandle param_type;
    681   static void Write(Message* m, const param_type& p);
    682   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    683   static void Log(const param_type& p, std::string* l);
    684 };
    685 
    686 template <>
    687 struct IPC_EXPORT ParamTraits<LogData> {
    688   typedef LogData param_type;
    689   static void Write(Message* m, const param_type& p);
    690   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    691   static void Log(const param_type& p, std::string* l);
    692 };
    693 
    694 template <>
    695 struct IPC_EXPORT ParamTraits<Message> {
    696   static void Write(Message* m, const Message& p);
    697   static bool Read(const Message* m, PickleIterator* iter, Message* r);
    698   static void Log(const Message& p, std::string* l);
    699 };
    700 
    701 // Windows ParamTraits ---------------------------------------------------------
    702 
    703 #if defined(OS_WIN)
    704 template <>
    705 struct IPC_EXPORT ParamTraits<HANDLE> {
    706   typedef HANDLE param_type;
    707   static void Write(Message* m, const param_type& p);
    708   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    709   static void Log(const param_type& p, std::string* l);
    710 };
    711 
    712 template <>
    713 struct IPC_EXPORT ParamTraits<LOGFONT> {
    714   typedef LOGFONT param_type;
    715   static void Write(Message* m, const param_type& p);
    716   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    717   static void Log(const param_type& p, std::string* l);
    718 };
    719 
    720 template <>
    721 struct IPC_EXPORT ParamTraits<MSG> {
    722   typedef MSG param_type;
    723   static void Write(Message* m, const param_type& p);
    724   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
    725   static void Log(const param_type& p, std::string* l);
    726 };
    727 #endif  // defined(OS_WIN)
    728 
    729 //-----------------------------------------------------------------------------
    730 // Generic message subclasses
    731 
    732 // Used for asynchronous messages.
    733 template <class ParamType>
    734 class MessageSchema {
    735  public:
    736   typedef ParamType Param;
    737   typedef typename TupleTypes<ParamType>::ParamTuple RefParam;
    738 
    739   static void Write(Message* msg, const RefParam& p) IPC_MSG_NOINLINE;
    740   static bool Read(const Message* msg, Param* p) IPC_MSG_NOINLINE;
    741 };
    742 
    743 // defined in ipc_logging.cc
    744 IPC_EXPORT void GenerateLogData(const std::string& channel,
    745                                 const Message& message,
    746                                 LogData* data, bool get_params);
    747 
    748 
    749 #if defined(IPC_MESSAGE_LOG_ENABLED)
    750 inline void AddOutputParamsToLog(const Message* msg, std::string* l) {
    751   const std::string& output_params = msg->output_params();
    752   if (!l->empty() && !output_params.empty())
    753     l->append(", ");
    754 
    755   l->append(output_params);
    756 }
    757 
    758 template <class ReplyParamType>
    759 inline void LogReplyParamsToMessage(const ReplyParamType& reply_params,
    760                                     const Message* msg) {
    761   if (msg->received_time() != 0) {
    762     std::string output_params;
    763     LogParam(reply_params, &output_params);
    764     msg->set_output_params(output_params);
    765   }
    766 }
    767 
    768 inline void ConnectMessageAndReply(const Message* msg, Message* reply) {
    769   if (msg->sent_time()) {
    770     // Don't log the sync message after dispatch, as we don't have the
    771     // output parameters at that point.  Instead, save its data and log it
    772     // with the outgoing reply message when it's sent.
    773     LogData* data = new LogData;
    774     GenerateLogData("", *msg, data, true);
    775     msg->set_dont_log();
    776     reply->set_sync_log_data(data);
    777   }
    778 }
    779 #else
    780 inline void AddOutputParamsToLog(const Message* msg, std::string* l) {}
    781 
    782 template <class ReplyParamType>
    783 inline void LogReplyParamsToMessage(const ReplyParamType& reply_params,
    784                                     const Message* msg) {}
    785 
    786 inline void ConnectMessageAndReply(const Message* msg, Message* reply) {}
    787 #endif
    788 
    789 // This class assumes that its template argument is a RefTuple (a Tuple with
    790 // reference elements). This would go into ipc_message_utils_impl.h, but it is
    791 // also used by chrome_frame.
    792 template <class RefTuple>
    793 class ParamDeserializer : public MessageReplyDeserializer {
    794  public:
    795   explicit ParamDeserializer(const RefTuple& out) : out_(out) { }
    796 
    797   bool SerializeOutputParameters(const IPC::Message& msg, PickleIterator iter) {
    798     return ReadParam(&msg, &iter, &out_);
    799   }
    800 
    801   RefTuple out_;
    802 };
    803 
    804 // Used for synchronous messages.
    805 template <class SendParamType, class ReplyParamType>
    806 class SyncMessageSchema {
    807  public:
    808   typedef SendParamType SendParam;
    809   typedef typename TupleTypes<SendParam>::ParamTuple RefSendParam;
    810   typedef ReplyParamType ReplyParam;
    811 
    812   static void Write(Message* msg, const RefSendParam& send) IPC_MSG_NOINLINE;
    813   static bool ReadSendParam(const Message* msg, SendParam* p) IPC_MSG_NOINLINE;
    814   static bool ReadReplyParam(
    815       const Message* msg,
    816       typename TupleTypes<ReplyParam>::ValueTuple* p) IPC_MSG_NOINLINE;
    817 
    818   template<class T, class S, class Method>
    819   static bool DispatchWithSendParams(bool ok, const SendParam& send_params,
    820                                      const Message* msg, T* obj, S* sender,
    821                                      Method func) {
    822     Message* reply = SyncMessage::GenerateReply(msg);
    823     if (ok) {
    824       typename TupleTypes<ReplyParam>::ValueTuple reply_params;
    825       DispatchToMethod(obj, func, send_params, &reply_params);
    826       WriteParam(reply, reply_params);
    827       LogReplyParamsToMessage(reply_params, msg);
    828     } else {
    829       NOTREACHED() << "Error deserializing message " << msg->type();
    830       reply->set_reply_error();
    831     }
    832     sender->Send(reply);
    833     return ok;
    834   }
    835 
    836   template<class T, class Method>
    837   static bool DispatchDelayReplyWithSendParams(bool ok,
    838                                                const SendParam& send_params,
    839                                                const Message* msg, T* obj,
    840                                                Method func) {
    841     Message* reply = SyncMessage::GenerateReply(msg);
    842     if (ok) {
    843       Tuple1<Message&> t = MakeRefTuple(*reply);
    844       ConnectMessageAndReply(msg, reply);
    845       DispatchToMethod(obj, func, send_params, &t);
    846     } else {
    847       NOTREACHED() << "Error deserializing message " << msg->type();
    848       reply->set_reply_error();
    849       obj->Send(reply);
    850     }
    851     return ok;
    852   }
    853 
    854   template<typename TA>
    855   static void WriteReplyParams(Message* reply, TA a) {
    856     ReplyParam p(a);
    857     WriteParam(reply, p);
    858   }
    859 
    860   template<typename TA, typename TB>
    861   static void WriteReplyParams(Message* reply, TA a, TB b) {
    862     ReplyParam p(a, b);
    863     WriteParam(reply, p);
    864   }
    865 
    866   template<typename TA, typename TB, typename TC>
    867   static void WriteReplyParams(Message* reply, TA a, TB b, TC c) {
    868     ReplyParam p(a, b, c);
    869     WriteParam(reply, p);
    870   }
    871 
    872   template<typename TA, typename TB, typename TC, typename TD>
    873   static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d) {
    874     ReplyParam p(a, b, c, d);
    875     WriteParam(reply, p);
    876   }
    877 
    878   template<typename TA, typename TB, typename TC, typename TD, typename TE>
    879   static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d, TE e) {
    880     ReplyParam p(a, b, c, d, e);
    881     WriteParam(reply, p);
    882   }
    883 };
    884 
    885 }  // namespace IPC
    886 
    887 #endif  // IPC_IPC_MESSAGE_UTILS_H_
    888