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