ipc/ipc_message_utils.h

   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   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 221   static void Log(const param_type& p, std::string* l);
 222 };
 223
 224 template <>
 225 struct IPC_EXPORT ParamTraits<double> {
 226   typedef double param_type;
 227   static void Write(Message* m, const param_type& p);
 228   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 229   static void Log(const param_type& p, std::string* l);
 230 };
 231
 232 // STL ParamTraits -------------------------------------------------------------
 233
 234 template <>
 235 struct ParamTraits<std::string> {
 236   typedef std::string param_type;
 237   static void Write(Message* m, const param_type& p) {
 238     m->WriteString(p);
 239   }
 240   static bool Read(const Message* m, PickleIterator* iter,
 241                    param_type* r) {
 242     return m->ReadString(iter, r);
 243   }
 244   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 245 };
 246
 247 template <>
 248 struct ParamTraits<std::wstring> {
 249   typedef std::wstring param_type;
 250   static void Write(Message* m, const param_type& p) {
 251     m->WriteWString(p);
 252   }
 253   static bool Read(const Message* m, PickleIterator* iter,
 254                    param_type* r) {
 255     return m->ReadWString(iter, r);
 256   }
 257   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 258 };
 259
 260 // If WCHAR_T_IS_UTF16 is defined, then string16 is a std::wstring so we don't
 261 // need this trait.
 262 #if !defined(WCHAR_T_IS_UTF16)
 263 template <>
 264 struct ParamTraits<string16> {
 265   typedef string16 param_type;
 266   static void Write(Message* m, const param_type& p) {
 267     m->WriteString16(p);
 268   }
 269   static bool Read(const Message* m, PickleIterator* iter,
 270                    param_type* r) {
 271     return m->ReadString16(iter, r);
 272   }
 273   IPC_EXPORT static void Log(const param_type& p, std::string* l);
 274 };
 275 #endif
 276
 277 template <>
 278 struct IPC_EXPORT ParamTraits<std::vector<char> > {
 279   typedef std::vector<char> param_type;
 280   static void Write(Message* m, const param_type& p);
 281   static bool Read(const Message*, PickleIterator* iter, param_type* r);
 282   static void Log(const param_type& p, std::string* l);
 283 };
 284
 285 template <>
 286 struct IPC_EXPORT ParamTraits<std::vector<unsigned char> > {
 287   typedef std::vector<unsigned char> param_type;
 288   static void Write(Message* m, const param_type& p);
 289   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 290   static void Log(const param_type& p, std::string* l);
 291 };
 292
 293 template <>
 294 struct IPC_EXPORT ParamTraits<std::vector<bool> > {
 295   typedef std::vector<bool> param_type;
 296   static void Write(Message* m, const param_type& p);
 297   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 298   static void Log(const param_type& p, std::string* l);
 299 };
 300
 301 template <class P>
 302 struct ParamTraits<std::vector<P> > {
 303   typedef std::vector<P> param_type;
 304   static void Write(Message* m, const param_type& p) {
 305     WriteParam(m, static_cast<int>(p.size()));
 306     for (size_t i = 0; i < p.size(); i++)
 307       WriteParam(m, p[i]);
 308   }
 309   static bool Read(const Message* m, PickleIterator* iter,
 310                    param_type* r) {
 311     int size;
 312     // ReadLength() checks for < 0 itself.
 313     if (!m->ReadLength(iter, &size))
 314       return false;
 315     // Resizing beforehand is not safe, see BUG 1006367 for details.
 316     if (INT_MAX / sizeof(P) <= static_cast<size_t>(size))
 317       return false;
 318     r->resize(size);
 319     for (int i = 0; i < size; i++) {
 320       if (!ReadParam(m, iter, &(*r)[i]))
 321         return false;
 322     }
 323     return true;
 324   }
 325   static void Log(const param_type& p, std::string* l) {
 326     for (size_t i = 0; i < p.size(); ++i) {
 327       if (i != 0)
 328         l->append(" ");
 329       LogParam((p[i]), l);
 330     }
 331   }
 332 };
 333
 334 template <class P>
 335 struct ParamTraits<std::set<P> > {
 336   typedef std::set<P> param_type;
 337   static void Write(Message* m, const param_type& p) {
 338     WriteParam(m, static_cast<int>(p.size()));
 339     typename param_type::const_iterator iter;
 340     for (iter = p.begin(); iter != p.end(); ++iter)
 341       WriteParam(m, *iter);
 342   }
 343   static bool Read(const Message* m, PickleIterator* iter,
 344                    param_type* r) {
 345     int size;
 346     if (!m->ReadLength(iter, &size))
 347       return false;
 348     for (int i = 0; i < size; ++i) {
 349       P item;
 350       if (!ReadParam(m, iter, &item))
 351         return false;
 352       r->insert(item);
 353     }
 354     return true;
 355   }
 356   static void Log(const param_type& p, std::string* l) {
 357     l->append("<std::set>");
 358   }
 359 };
 360
 361 template <class K, class V>
 362 struct ParamTraits<std::map<K, V> > {
 363   typedef std::map<K, V> param_type;
 364   static void Write(Message* m, const param_type& p) {
 365     WriteParam(m, static_cast<int>(p.size()));
 366     typename param_type::const_iterator iter;
 367     for (iter = p.begin(); iter != p.end(); ++iter) {
 368       WriteParam(m, iter->first);
 369       WriteParam(m, iter->second);
 370     }
 371   }
 372   static bool Read(const Message* m, PickleIterator* iter,
 373                    param_type* r) {
 374     int size;
 375     if (!ReadParam(m, iter, &size) || size < 0)
 376       return false;
 377     for (int i = 0; i < size; ++i) {
 378       K k;
 379       if (!ReadParam(m, iter, &k))
 380         return false;
 381       V& value = (*r)[k];
 382       if (!ReadParam(m, iter, &value))
 383         return false;
 384     }
 385     return true;
 386   }
 387   static void Log(const param_type& p, std::string* l) {
 388     l->append("<std::map>");
 389   }
 390 };
 391
 392 template <class A, class B>
 393 struct ParamTraits<std::pair<A, B> > {
 394   typedef std::pair<A, B> param_type;
 395   static void Write(Message* m, const param_type& p) {
 396     WriteParam(m, p.first);
 397     WriteParam(m, p.second);
 398   }
 399   static bool Read(const Message* m, PickleIterator* iter,
 400                    param_type* r) {
 401     return ReadParam(m, iter, &r->first) && ReadParam(m, iter, &r->second);
 402   }
 403   static void Log(const param_type& p, std::string* l) {
 404     l->append("(");
 405     LogParam(p.first, l);
 406     l->append(", ");
 407     LogParam(p.second, l);
 408     l->append(")");
 409   }
 410 };
 411
 412 // Base ParamTraits ------------------------------------------------------------
 413
 414 template <>
 415 struct IPC_EXPORT ParamTraits<base::DictionaryValue> {
 416   typedef base::DictionaryValue param_type;
 417   static void Write(Message* m, const param_type& p);
 418   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 419   static void Log(const param_type& p, std::string* l);
 420 };
 421
 422 #if defined(OS_POSIX)
 423 // FileDescriptors may be serialised over IPC channels on POSIX. On the
 424 // receiving side, the FileDescriptor is a valid duplicate of the file
 425 // descriptor which was transmitted: *it is not just a copy of the integer like
 426 // HANDLEs on Windows*. The only exception is if the file descriptor is < 0. In
 427 // this case, the receiving end will see a value of -1. *Zero is a valid file
 428 // descriptor*.
 429 //
 430 // The received file descriptor will have the |auto_close| flag set to true. The
 431 // code which handles the message is responsible for taking ownership of it.
 432 // File descriptors are OS resources and must be closed when no longer needed.
 433 //
 434 // When sending a file descriptor, the file descriptor must be valid at the time
 435 // of transmission. Since transmission is not synchronous, one should consider
 436 // dup()ing any file descriptors to be transmitted and setting the |auto_close|
 437 // flag, which causes the file descriptor to be closed after writing.
 438 template<>
 439 struct IPC_EXPORT ParamTraits<base::FileDescriptor> {
 440   typedef base::FileDescriptor param_type;
 441   static void Write(Message* m, const param_type& p);
 442   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 443   static void Log(const param_type& p, std::string* l);
 444 };
 445 #endif  // defined(OS_POSIX)
 446
 447 template <>
 448 struct IPC_EXPORT ParamTraits<base::FilePath> {
 449   typedef base::FilePath param_type;
 450   static void Write(Message* m, const param_type& p);
 451   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 452   static void Log(const param_type& p, std::string* l);
 453 };
 454
 455 template <>
 456 struct IPC_EXPORT ParamTraits<base::ListValue> {
 457   typedef base::ListValue param_type;
 458   static void Write(Message* m, const param_type& p);
 459   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 460   static void Log(const param_type& p, std::string* l);
 461 };
 462
 463 template <>
 464 struct IPC_EXPORT ParamTraits<base::NullableString16> {
 465   typedef base::NullableString16 param_type;
 466   static void Write(Message* m, const param_type& p);
 467   static bool Read(const Message* m, PickleIterator* iter,
 468                    param_type* r);
 469   static void Log(const param_type& p, std::string* l);
 470 };
 471
 472 template <>
 473 struct IPC_EXPORT ParamTraits<base::PlatformFileInfo> {
 474   typedef base::PlatformFileInfo param_type;
 475   static void Write(Message* m, const param_type& p);
 476   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 477   static void Log(const param_type& p, std::string* l);
 478 };
 479
 480 template <>
 481 struct SimilarTypeTraits<base::PlatformFileError> {
 482   typedef int Type;
 483 };
 484
 485 #if defined(OS_WIN)
 486 template <>
 487 struct SimilarTypeTraits<HWND> {
 488   typedef HANDLE Type;
 489 };
 490 #endif  // defined(OS_WIN)
 491
 492 template <>
 493 struct IPC_EXPORT ParamTraits<base::Time> {
 494   typedef base::Time param_type;
 495   static void Write(Message* m, const param_type& p);
 496   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 497   static void Log(const param_type& p, std::string* l);
 498 };
 499
 500 template <>
 501 struct IPC_EXPORT ParamTraits<base::TimeDelta> {
 502   typedef base::TimeDelta param_type;
 503   static void Write(Message* m, const param_type& p);
 504   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 505   static void Log(const param_type& p, std::string* l);
 506 };
 507
 508 template <>
 509 struct IPC_EXPORT ParamTraits<base::TimeTicks> {
 510   typedef base::TimeTicks param_type;
 511   static void Write(Message* m, const param_type& p);
 512   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 513   static void Log(const param_type& p, std::string* l);
 514 };
 515
 516 template <>
 517 struct ParamTraits<Tuple0> {
 518   typedef Tuple0 param_type;
 519   static void Write(Message* m, const param_type& p) {
 520   }
 521   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 522     return true;
 523   }
 524   static void Log(const param_type& p, std::string* l) {
 525   }
 526 };
 527
 528 template <class A>
 529 struct ParamTraits< Tuple1<A> > {
 530   typedef Tuple1<A> param_type;
 531   static void Write(Message* m, const param_type& p) {
 532     WriteParam(m, p.a);
 533   }
 534   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 535     return ReadParam(m, iter, &r->a);
 536   }
 537   static void Log(const param_type& p, std::string* l) {
 538     LogParam(p.a, l);
 539   }
 540 };
 541
 542 template <class A, class B>
 543 struct ParamTraits< Tuple2<A, B> > {
 544   typedef Tuple2<A, B> param_type;
 545   static void Write(Message* m, const param_type& p) {
 546     WriteParam(m, p.a);
 547     WriteParam(m, p.b);
 548   }
 549   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 550     return (ReadParam(m, iter, &r->a) &&
 551             ReadParam(m, iter, &r->b));
 552   }
 553   static void Log(const param_type& p, std::string* l) {
 554     LogParam(p.a, l);
 555     l->append(", ");
 556     LogParam(p.b, l);
 557   }
 558 };
 559
 560 template <class A, class B, class C>
 561 struct ParamTraits< Tuple3<A, B, C> > {
 562   typedef Tuple3<A, B, C> param_type;
 563   static void Write(Message* m, const param_type& p) {
 564     WriteParam(m, p.a);
 565     WriteParam(m, p.b);
 566     WriteParam(m, p.c);
 567   }
 568   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 569     return (ReadParam(m, iter, &r->a) &&
 570             ReadParam(m, iter, &r->b) &&
 571             ReadParam(m, iter, &r->c));
 572   }
 573   static void Log(const param_type& p, std::string* l) {
 574     LogParam(p.a, l);
 575     l->append(", ");
 576     LogParam(p.b, l);
 577     l->append(", ");
 578     LogParam(p.c, l);
 579   }
 580 };
 581
 582 template <class A, class B, class C, class D>
 583 struct ParamTraits< Tuple4<A, B, C, D> > {
 584   typedef Tuple4<A, B, C, D> param_type;
 585   static void Write(Message* m, const param_type& p) {
 586     WriteParam(m, p.a);
 587     WriteParam(m, p.b);
 588     WriteParam(m, p.c);
 589     WriteParam(m, p.d);
 590   }
 591   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 592     return (ReadParam(m, iter, &r->a) &&
 593             ReadParam(m, iter, &r->b) &&
 594             ReadParam(m, iter, &r->c) &&
 595             ReadParam(m, iter, &r->d));
 596   }
 597   static void Log(const param_type& p, std::string* l) {
 598     LogParam(p.a, l);
 599     l->append(", ");
 600     LogParam(p.b, l);
 601     l->append(", ");
 602     LogParam(p.c, l);
 603     l->append(", ");
 604     LogParam(p.d, l);
 605   }
 606 };
 607
 608 template <class A, class B, class C, class D, class E>
 609 struct ParamTraits< Tuple5<A, B, C, D, E> > {
 610   typedef Tuple5<A, B, C, D, E> param_type;
 611   static void Write(Message* m, const param_type& p) {
 612     WriteParam(m, p.a);
 613     WriteParam(m, p.b);
 614     WriteParam(m, p.c);
 615     WriteParam(m, p.d);
 616     WriteParam(m, p.e);
 617   }
 618   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 619     return (ReadParam(m, iter, &r->a) &&
 620             ReadParam(m, iter, &r->b) &&
 621             ReadParam(m, iter, &r->c) &&
 622             ReadParam(m, iter, &r->d) &&
 623             ReadParam(m, iter, &r->e));
 624   }
 625   static void Log(const param_type& p, std::string* l) {
 626     LogParam(p.a, l);
 627     l->append(", ");
 628     LogParam(p.b, l);
 629     l->append(", ");
 630     LogParam(p.c, l);
 631     l->append(", ");
 632     LogParam(p.d, l);
 633     l->append(", ");
 634     LogParam(p.e, l);
 635   }
 636 };
 637
 638 template<class P>
 639 struct ParamTraits<ScopedVector<P> > {
 640   typedef ScopedVector<P> param_type;
 641   static void Write(Message* m, const param_type& p) {
 642     WriteParam(m, static_cast<int>(p.size()));
 643     for (size_t i = 0; i < p.size(); i++)
 644       WriteParam(m, *p[i]);
 645   }
 646   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 647     int size = 0;
 648     if (!m->ReadLength(iter, &size))
 649       return false;
 650     if (INT_MAX/sizeof(P) <= static_cast<size_t>(size))
 651       return false;
 652     r->resize(size);
 653     for (int i = 0; i < size; i++) {
 654       (*r)[i] = new P();
 655       if (!ReadParam(m, iter, (*r)[i]))
 656         return false;
 657     }
 658     return true;
 659   }
 660   static void Log(const param_type& p, std::string* l) {
 661     for (size_t i = 0; i < p.size(); ++i) {
 662       if (i != 0)
 663         l->append(" ");
 664       LogParam(*p[i], l);
 665     }
 666   }
 667 };
 668
 669 // IPC types ParamTraits -------------------------------------------------------
 670
 671 // A ChannelHandle is basically a platform-inspecific wrapper around the
 672 // fact that IPC endpoints are handled specially on POSIX.  See above comments
 673 // on FileDescriptor for more background.
 674 template<>
 675 struct IPC_EXPORT ParamTraits<IPC::ChannelHandle> {
 676   typedef ChannelHandle param_type;
 677   static void Write(Message* m, const param_type& p);
 678   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 679   static void Log(const param_type& p, std::string* l);
 680 };
 681
 682 template <>
 683 struct IPC_EXPORT ParamTraits<LogData> {
 684   typedef LogData param_type;
 685   static void Write(Message* m, const param_type& p);
 686   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 687   static void Log(const param_type& p, std::string* l);
 688 };
 689
 690 template <>
 691 struct IPC_EXPORT ParamTraits<Message> {
 692   static void Write(Message* m, const Message& p);
 693   static bool Read(const Message* m, PickleIterator* iter, Message* r);
 694   static void Log(const Message& p, std::string* l);
 695 };
 696
 697 // Windows ParamTraits ---------------------------------------------------------
 698
 699 #if defined(OS_WIN)
 700 template <>
 701 struct IPC_EXPORT ParamTraits<HANDLE> {
 702   typedef HANDLE param_type;
 703   static void Write(Message* m, const param_type& p);
 704   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 705   static void Log(const param_type& p, std::string* l);
 706 };
 707
 708 template <>
 709 struct IPC_EXPORT ParamTraits<LOGFONT> {
 710   typedef LOGFONT param_type;
 711   static void Write(Message* m, const param_type& p);
 712   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 713   static void Log(const param_type& p, std::string* l);
 714 };
 715
 716 template <>
 717 struct IPC_EXPORT ParamTraits<MSG> {
 718   typedef MSG param_type;
 719   static void Write(Message* m, const param_type& p);
 720   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
 721   static void Log(const param_type& p, std::string* l);
 722 };
 723 #endif  // defined(OS_WIN)
 724
 725 //-----------------------------------------------------------------------------
 726 // Generic message subclasses
 727
 728 // Used for asynchronous messages.
 729 template <class ParamType>
 730 class MessageSchema {
 731  public:
 732   typedef ParamType Param;
 733   typedef typename TupleTypes<ParamType>::ParamTuple RefParam;
 734
 735   static void Write(Message* msg, const RefParam& p) IPC_MSG_NOINLINE;
 736   static bool Read(const Message* msg, Param* p) IPC_MSG_NOINLINE;
 737 };
 738
 739 // defined in ipc_logging.cc
 740 IPC_EXPORT void GenerateLogData(const std::string& channel,
 741                                 const Message& message,
 742                                 LogData* data, bool get_params);
 743
 744
 745 #if defined(IPC_MESSAGE_LOG_ENABLED)
 746 inline void AddOutputParamsToLog(const Message* msg, std::string* l) {
 747   const std::string& output_params = msg->output_params();
 748   if (!l->empty() && !output_params.empty())
 749     l->append(", ");
 750
 751   l->append(output_params);
 752 }
 753
 754 template <class ReplyParamType>
 755 inline void LogReplyParamsToMessage(const ReplyParamType& reply_params,
 756                                     const Message* msg) {
 757   if (msg->received_time() != 0) {
 758     std::string output_params;
 759     LogParam(reply_params, &output_params);
 760     msg->set_output_params(output_params);
 761   }
 762 }
 763
 764 inline void ConnectMessageAndReply(const Message* msg, Message* reply) {
 765   if (msg->sent_time()) {
 766     // Don't log the sync message after dispatch, as we don't have the
 767     // output parameters at that point.  Instead, save its data and log it
 768     // with the outgoing reply message when it's sent.
 769     LogData* data = new LogData;
 770     GenerateLogData("", *msg, data, true);
 771     msg->set_dont_log();
 772     reply->set_sync_log_data(data);
 773   }
 774 }
 775 #else
 776 inline void AddOutputParamsToLog(const Message* msg, std::string* l) {}
 777
 778 template <class ReplyParamType>
 779 inline void LogReplyParamsToMessage(const ReplyParamType& reply_params,
 780                                     const Message* msg) {}
 781
 782 inline void ConnectMessageAndReply(const Message* msg, Message* reply) {}
 783 #endif
 784
 785 // This class assumes that its template argument is a RefTuple (a Tuple with
 786 // reference elements). This would go into ipc_message_utils_impl.h, but it is
 787 // also used by chrome_frame.
 788 template <class RefTuple>
 789 class ParamDeserializer : public MessageReplyDeserializer {
 790  public:
 791   explicit ParamDeserializer(const RefTuple& out) : out_(out) { }
 792
 793   bool SerializeOutputParameters(const IPC::Message& msg, PickleIterator iter) {
 794     return ReadParam(&msg, &iter, &out_);
 795   }
 796
 797   RefTuple out_;
 798 };
 799
 800 // Used for synchronous messages.
 801 template <class SendParamType, class ReplyParamType>
 802 class SyncMessageSchema {
 803  public:
 804   typedef SendParamType SendParam;
 805   typedef typename TupleTypes<SendParam>::ParamTuple RefSendParam;
 806   typedef ReplyParamType ReplyParam;
 807
 808   static void Write(Message* msg, const RefSendParam& send) IPC_MSG_NOINLINE;
 809   static bool ReadSendParam(const Message* msg, SendParam* p) IPC_MSG_NOINLINE;
 810   static bool ReadReplyParam(
 811       const Message* msg,
 812       typename TupleTypes<ReplyParam>::ValueTuple* p) IPC_MSG_NOINLINE;
 813
 814   template<class T, class S, class Method>
 815   static bool DispatchWithSendParams(bool ok, const SendParam& send_params,
 816                                      const Message* msg, T* obj, S* sender,
 817                                      Method func) {
 818     Message* reply = SyncMessage::GenerateReply(msg);
 819     if (ok) {
 820       typename TupleTypes<ReplyParam>::ValueTuple reply_params;
 821       DispatchToMethod(obj, func, send_params, &reply_params);
 822       WriteParam(reply, reply_params);
 823       LogReplyParamsToMessage(reply_params, msg);
 824     } else {
 825       NOTREACHED() << "Error deserializing message " << msg->type();
 826       reply->set_reply_error();
 827     }
 828     sender->Send(reply);
 829     return ok;
 830   }
 831
 832   template<class T, class Method>
 833   static bool DispatchDelayReplyWithSendParams(bool ok,
 834                                                const SendParam& send_params,
 835                                                const Message* msg, T* obj,
 836                                                Method func) {
 837     Message* reply = SyncMessage::GenerateReply(msg);
 838     if (ok) {
 839       Tuple1<Message&> t = MakeRefTuple(*reply);
 840       ConnectMessageAndReply(msg, reply);
 841       DispatchToMethod(obj, func, send_params, &t);
 842     } else {
 843       NOTREACHED() << "Error deserializing message " << msg->type();
 844       reply->set_reply_error();
 845       obj->Send(reply);
 846     }
 847     return ok;
 848   }
 849
 850   template<typename TA>
 851   static void WriteReplyParams(Message* reply, TA a) {
 852     ReplyParam p(a);
 853     WriteParam(reply, p);
 854   }
 855
 856   template<typename TA, typename TB>
 857   static void WriteReplyParams(Message* reply, TA a, TB b) {
 858     ReplyParam p(a, b);
 859     WriteParam(reply, p);
 860   }
 861
 862   template<typename TA, typename TB, typename TC>
 863   static void WriteReplyParams(Message* reply, TA a, TB b, TC c) {
 864     ReplyParam p(a, b, c);
 865     WriteParam(reply, p);
 866   }
 867
 868   template<typename TA, typename TB, typename TC, typename TD>
 869   static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d) {
 870     ReplyParam p(a, b, c, d);
 871     WriteParam(reply, p);
 872   }
 873
 874   template<typename TA, typename TB, typename TC, typename TD, typename TE>
 875   static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d, TE e) {
 876     ReplyParam p(a, b, c, d, e);
 877     WriteParam(reply, p);
 878   }
 879 };
 880
 881 }  // namespace IPC
 882
 883 #endif  // IPC_IPC_MESSAGE_UTILS_H_