Reapplies all the IPC system work (reverts the revert r56272).

ipc/ipc_message_macros.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This header is meant to be included in multiple passes, hence no traditional
 // header guard.
 //
 // In the first pass, IPC_MESSAGE_MACROS_ENUMS should be defined, which will
 // create enums for each of the messages defined with the IPC_MESSAGE_* macros.
 //
@@ skipping 61 matching lines @@
 #ifdef IPC_MESSAGE_MACROS_LOG_ENABLED
 #define IPC_MESSAGE_MACROS_LOG
 #include MESSAGES_INTERNAL_FILE
 #endif
 
 #undef MESSAGES_INTERNAL_FILE
 #undef IPC_MESSAGE_MACROS_INCLUDE_BLOCK
 
 #endif
 
+#if defined(IPC_MESSAGE_MACROS_ENUMS)
+#undef IPC_MESSAGE_MACROS_ENUMS
+
 
 // Undefine the macros from the previous pass (if any).
 #undef IPC_BEGIN_MESSAGES
 #undef IPC_END_MESSAGES
 #undef IPC_MESSAGE_CONTROL0
 #undef IPC_MESSAGE_CONTROL1
 #undef IPC_MESSAGE_CONTROL2
 #undef IPC_MESSAGE_CONTROL3
 #undef IPC_MESSAGE_CONTROL4
 #undef IPC_MESSAGE_CONTROL5
@@ skipping 39 matching lines @@
 #undef IPC_SYNC_MESSAGE_ROUTED3_3
 #undef IPC_SYNC_MESSAGE_ROUTED4_0
 #undef IPC_SYNC_MESSAGE_ROUTED4_1
 #undef IPC_SYNC_MESSAGE_ROUTED4_2
 #undef IPC_SYNC_MESSAGE_ROUTED4_3
 #undef IPC_SYNC_MESSAGE_ROUTED5_0
 #undef IPC_SYNC_MESSAGE_ROUTED5_1
 #undef IPC_SYNC_MESSAGE_ROUTED5_2
 #undef IPC_SYNC_MESSAGE_ROUTED5_3
 
-#if defined(IPC_MESSAGE_MACROS_ENUMS)
-#undef IPC_MESSAGE_MACROS_ENUMS
-
 // We're using the lowest 16 bits of type for the message id, and the highest
 // 16 bits for the channel type.
 //
 // Do label##PreStart so that automation messages keep the same id as before.
 #define IPC_BEGIN_MESSAGES(label) \
   enum label##MsgType { \
   label##Start = label##MsgStart << 16, \
   label##PreStart = (label##MsgStart << 16) - 1,
 
 #define IPC_END_MESSAGES(label) \
@@ skipping 238 matching lines @@
   } \
 }
 
 #define IPC_END_MESSAGE_MAP_EX() \
   } \
 }
 
 #elif defined(IPC_MESSAGE_MACROS_LOG)
 #undef IPC_MESSAGE_MACROS_LOG
 
+
+// Undefine the macros from the previous pass (if any).
+#undef IPC_BEGIN_MESSAGES
+#undef IPC_END_MESSAGES
+#undef IPC_MESSAGE_CONTROL0
+#undef IPC_MESSAGE_CONTROL1
+#undef IPC_MESSAGE_CONTROL2
+#undef IPC_MESSAGE_CONTROL3
+#undef IPC_MESSAGE_CONTROL4
+#undef IPC_MESSAGE_CONTROL5
+#undef IPC_MESSAGE_ROUTED0
+#undef IPC_MESSAGE_ROUTED1
+#undef IPC_MESSAGE_ROUTED2
+#undef IPC_MESSAGE_ROUTED3
+#undef IPC_MESSAGE_ROUTED4
+#undef IPC_MESSAGE_ROUTED5
+#undef IPC_SYNC_MESSAGE_CONTROL0_0
+#undef IPC_SYNC_MESSAGE_CONTROL0_1
+#undef IPC_SYNC_MESSAGE_CONTROL0_2
+#undef IPC_SYNC_MESSAGE_CONTROL0_3
+#undef IPC_SYNC_MESSAGE_CONTROL1_0
+#undef IPC_SYNC_MESSAGE_CONTROL1_1
+#undef IPC_SYNC_MESSAGE_CONTROL1_2
+#undef IPC_SYNC_MESSAGE_CONTROL1_3
+#undef IPC_SYNC_MESSAGE_CONTROL2_0
+#undef IPC_SYNC_MESSAGE_CONTROL2_1
+#undef IPC_SYNC_MESSAGE_CONTROL2_2
+#undef IPC_SYNC_MESSAGE_CONTROL2_3
+#undef IPC_SYNC_MESSAGE_CONTROL3_1
+#undef IPC_SYNC_MESSAGE_CONTROL3_2
+#undef IPC_SYNC_MESSAGE_CONTROL3_3
+#undef IPC_SYNC_MESSAGE_CONTROL4_1
+#undef IPC_SYNC_MESSAGE_CONTROL4_2
+#undef IPC_SYNC_MESSAGE_ROUTED0_0
+#undef IPC_SYNC_MESSAGE_ROUTED0_1
+#undef IPC_SYNC_MESSAGE_ROUTED0_2
+#undef IPC_SYNC_MESSAGE_ROUTED0_3
+#undef IPC_SYNC_MESSAGE_ROUTED1_0
+#undef IPC_SYNC_MESSAGE_ROUTED1_1
+#undef IPC_SYNC_MESSAGE_ROUTED1_2
+#undef IPC_SYNC_MESSAGE_ROUTED1_3
+#undef IPC_SYNC_MESSAGE_ROUTED1_4
+#undef IPC_SYNC_MESSAGE_ROUTED2_0
+#undef IPC_SYNC_MESSAGE_ROUTED2_1
+#undef IPC_SYNC_MESSAGE_ROUTED2_2
+#undef IPC_SYNC_MESSAGE_ROUTED2_3
+#undef IPC_SYNC_MESSAGE_ROUTED3_0
+#undef IPC_SYNC_MESSAGE_ROUTED3_1
+#undef IPC_SYNC_MESSAGE_ROUTED3_2
+#undef IPC_SYNC_MESSAGE_ROUTED3_3
+#undef IPC_SYNC_MESSAGE_ROUTED4_0
+#undef IPC_SYNC_MESSAGE_ROUTED4_1
+#undef IPC_SYNC_MESSAGE_ROUTED4_2
+#undef IPC_SYNC_MESSAGE_ROUTED4_3
+#undef IPC_SYNC_MESSAGE_ROUTED5_0
+#undef IPC_SYNC_MESSAGE_ROUTED5_1
+#undef IPC_SYNC_MESSAGE_ROUTED5_2
+#undef IPC_SYNC_MESSAGE_ROUTED5_3
+
 #ifndef IPC_LOG_TABLE_CREATED
 #define IPC_LOG_TABLE_CREATED
 typedef void (*LogFunction)(uint32 type,
                            std::wstring* name,
                            const IPC::Message* msg,
                            std::wstring* params);
 
 LogFunction g_log_function_mapping[LastMsgIndex];
 #endif
 
@@ skipping 182 matching lines @@
 
 #define IPC_SYNC_MESSAGE_ROUTED5_2(msg_class, type1_in, type2_in, type3_in, type4_in, type5_in, type1_out, type2_out) \
   IPC_MESSAGE_LOG(msg_class)
 
 #define IPC_SYNC_MESSAGE_ROUTED5_3(msg_class, type1_in, type2_in, type3_in, type4_in, type5_in, type1_out, type2_out, type3_out) \
   IPC_MESSAGE_LOG(msg_class)
 
 #elif defined(IPC_MESSAGE_MACROS_CLASSES)
 #undef IPC_MESSAGE_MACROS_CLASSES
 
+
+// Undefine the macros from the previous pass (if any).
+#undef IPC_BEGIN_MESSAGES
+#undef IPC_END_MESSAGES
+#undef IPC_MESSAGE_CONTROL0
+#undef IPC_MESSAGE_CONTROL1
+#undef IPC_MESSAGE_CONTROL2
+#undef IPC_MESSAGE_CONTROL3
+#undef IPC_MESSAGE_CONTROL4
+#undef IPC_MESSAGE_CONTROL5
+#undef IPC_MESSAGE_ROUTED0
+#undef IPC_MESSAGE_ROUTED1
+#undef IPC_MESSAGE_ROUTED2
+#undef IPC_MESSAGE_ROUTED3
+#undef IPC_MESSAGE_ROUTED4
+#undef IPC_MESSAGE_ROUTED5
+#undef IPC_SYNC_MESSAGE_CONTROL0_0
+#undef IPC_SYNC_MESSAGE_CONTROL0_1
+#undef IPC_SYNC_MESSAGE_CONTROL0_2
+#undef IPC_SYNC_MESSAGE_CONTROL0_3
+#undef IPC_SYNC_MESSAGE_CONTROL1_0
+#undef IPC_SYNC_MESSAGE_CONTROL1_1
+#undef IPC_SYNC_MESSAGE_CONTROL1_2
+#undef IPC_SYNC_MESSAGE_CONTROL1_3
+#undef IPC_SYNC_MESSAGE_CONTROL2_0
+#undef IPC_SYNC_MESSAGE_CONTROL2_1
+#undef IPC_SYNC_MESSAGE_CONTROL2_2
+#undef IPC_SYNC_MESSAGE_CONTROL2_3
+#undef IPC_SYNC_MESSAGE_CONTROL3_1
+#undef IPC_SYNC_MESSAGE_CONTROL3_2
+#undef IPC_SYNC_MESSAGE_CONTROL3_3
+#undef IPC_SYNC_MESSAGE_CONTROL4_1
+#undef IPC_SYNC_MESSAGE_CONTROL4_2
+#undef IPC_SYNC_MESSAGE_ROUTED0_0
+#undef IPC_SYNC_MESSAGE_ROUTED0_1
+#undef IPC_SYNC_MESSAGE_ROUTED0_2
+#undef IPC_SYNC_MESSAGE_ROUTED0_3
+#undef IPC_SYNC_MESSAGE_ROUTED1_0
+#undef IPC_SYNC_MESSAGE_ROUTED1_1
+#undef IPC_SYNC_MESSAGE_ROUTED1_2
+#undef IPC_SYNC_MESSAGE_ROUTED1_3
+#undef IPC_SYNC_MESSAGE_ROUTED1_4
+#undef IPC_SYNC_MESSAGE_ROUTED2_0
+#undef IPC_SYNC_MESSAGE_ROUTED2_1
+#undef IPC_SYNC_MESSAGE_ROUTED2_2
+#undef IPC_SYNC_MESSAGE_ROUTED2_3
+#undef IPC_SYNC_MESSAGE_ROUTED3_0
+#undef IPC_SYNC_MESSAGE_ROUTED3_1
+#undef IPC_SYNC_MESSAGE_ROUTED3_2
+#undef IPC_SYNC_MESSAGE_ROUTED3_3
+#undef IPC_SYNC_MESSAGE_ROUTED4_0
+#undef IPC_SYNC_MESSAGE_ROUTED4_1
+#undef IPC_SYNC_MESSAGE_ROUTED4_2
+#undef IPC_SYNC_MESSAGE_ROUTED4_3
+#undef IPC_SYNC_MESSAGE_ROUTED5_0
+#undef IPC_SYNC_MESSAGE_ROUTED5_1
+#undef IPC_SYNC_MESSAGE_ROUTED5_2
+#undef IPC_SYNC_MESSAGE_ROUTED5_3
+
 #define IPC_BEGIN_MESSAGES(label)
 #define IPC_END_MESSAGES(label)
 
 #define IPC_MESSAGE_CONTROL0(msg_class) \
   class msg_class : public IPC::Message { \
    public: \
    enum { ID = msg_class##__ID }; \
     msg_class() \
         : IPC::Message(MSG_ROUTING_CONTROL, \
                        ID, \
                        PRIORITY_NORMAL) {} \
   };
 
 #define IPC_MESSAGE_CONTROL1(msg_class, type1) \
   class msg_class : public IPC::MessageWithTuple< Tuple1<type1> > { \
-   public: \
-   enum { ID = msg_class##__ID }; \
-    msg_class(const type1& arg1) \
-        : IPC::MessageWithTuple< Tuple1<type1> >(MSG_ROUTING_CONTROL, \
-                                       ID, \
-                                       MakeRefTuple(arg1)) {} \
+    public:                                                         \
+      enum { ID = msg_class##__ID };                                \
+      msg_class(const type1& arg1);                                 \
+      ~msg_class();                                                 \
+      static void Log(const Message* msg, std::wstring* l);         \
   };
 
-#define IPC_MESSAGE_CONTROL2(msg_class, type1, type2) \
+#define IPC_MESSAGE_CONTROL2(msg_class, type1, type2)                   \
   class msg_class : public IPC::MessageWithTuple< Tuple2<type1, type2> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(const type1& arg1, const type2& arg2) \
-        : IPC::MessageWithTuple< Tuple2<type1, type2> >( \
-              MSG_ROUTING_CONTROL, \
-              ID, \
-              MakeRefTuple(arg1, arg2)) {} \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(const type1& arg1, const type2& arg2);                  \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
-#define IPC_MESSAGE_CONTROL3(msg_class, type1, type2, type3) \
-  class msg_class : \
-      public IPC::MessageWithTuple< Tuple3<type1, type2, type3> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(const type1& arg1, const type2& arg2, const type3& arg3) \
-        : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \
-              MSG_ROUTING_CONTROL, \
-              ID, \
-              MakeRefTuple(arg1, arg2, arg3)) {} \
+#define IPC_MESSAGE_CONTROL3(msg_class, type1, type2, type3)            \
+  class msg_class :                                                     \
+      public IPC::MessageWithTuple< Tuple3<type1, type2, type3> > {     \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(const type1& arg1, const type2& arg2, const type3& arg3); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
-#define IPC_MESSAGE_CONTROL4(msg_class, type1, type2, type3, type4) \
-  class msg_class : \
+#define IPC_MESSAGE_CONTROL4(msg_class, type1, type2, type3, type4)     \
+  class msg_class :                                                     \
       public IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(const type1& arg1, const type2& arg2, const type3& arg3, \
-              const type4& arg4) \
-        : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \
-              MSG_ROUTING_CONTROL, \
-              ID, \
-              MakeRefTuple(arg1, arg2, arg3, arg4)) {} \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(const type1& arg1, const type2& arg2, const type3& arg3, \
+                const type4& arg4);                                     \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_MESSAGE_CONTROL5(msg_class, type1, type2, type3, type4, type5) \
-  class msg_class : \
+  class msg_class :                                                     \
       public IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(const type1& arg1, const type2& arg2, \
-              const type3& arg3, const type4& arg4, const type5& arg5) \
-        : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \
-            MSG_ROUTING_CONTROL, \
-            ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(const type1& arg1, const type2& arg2,                   \
+                const type3& arg3, const type4& arg4, const type5& arg5); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_MESSAGE_ROUTED0(msg_class) \
   class msg_class : public IPC::Message { \
    public: \
     enum { ID = msg_class##__ID }; \
     msg_class(int32 routing_id) \
         : IPC::Message(routing_id, ID, PRIORITY_NORMAL) {} \
   };
 
 #define IPC_MESSAGE_ROUTED1(msg_class, type1) \
-  class msg_class : public IPC::MessageWithTuple< Tuple1<type1> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(int32 routing_id, const type1& arg1) \
-        : IPC::MessageWithTuple< Tuple1<type1> >(routing_id, ID, \
-                                                 MakeRefTuple(arg1)) {} \
+  class msg_class : public IPC::MessageWithTuple< Tuple1<type1> > {     \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(int32 routing_id, const type1& arg1);                   \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
-#define IPC_MESSAGE_ROUTED2(msg_class, type1, type2) \
-  class msg_class : public IPC::MessageWithTuple< Tuple2<type1, type2> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(int32 routing_id, const type1& arg1, const type2& arg2) \
-        : IPC::MessageWithTuple< Tuple2<type1, type2> >( \
-            routing_id, ID, MakeRefTuple(arg1, arg2)) {} \
+#define IPC_MESSAGE_ROUTED2(msg_class, type1, type2)                    \
+  class msg_class                                                       \
+      : public IPC::MessageWithTuple< Tuple2<type1, type2> > {          \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(int32 routing_id, const type1& arg1, const type2& arg2); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
-#define IPC_MESSAGE_ROUTED3(msg_class, type1, type2, type3) \
-  class msg_class : \
-      public IPC::MessageWithTuple< Tuple3<type1, type2, type3> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \
-              const type3& arg3) \
-        : IPC::MessageWithTuple< Tuple3<type1, type2, type3> >( \
-            routing_id, ID, MakeRefTuple(arg1, arg2, arg3)) {} \
+#define IPC_MESSAGE_ROUTED3(msg_class, type1, type2, type3)             \
+  class msg_class                                                       \
+      : public IPC::MessageWithTuple< Tuple3<type1, type2, type3> > {   \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \
+                const type3& arg3);                                     \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
-#define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4) \
-  class msg_class : \
-      public IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \
-               const type3& arg3, const type4& arg4) \
-        : IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> >( \
-            routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4)) {} \
+#define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4)      \
+  class msg_class                                                       \
+      : public IPC::MessageWithTuple< Tuple4<type1, type2, type3, type4> > { \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \
+                const type3& arg3, const type4& arg4);                  \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_MESSAGE_ROUTED5(msg_class, type1, type2, type3, type4, type5) \
-  class msg_class : \
-      public IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> > { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \
-              const type3& arg3, const type4& arg4, const type5& arg5) \
-        : IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, type5> >( \
-            routing_id, ID, MakeRefTuple(arg1, arg2, arg3, arg4, arg5)) {} \
+  class msg_class                                                       \
+      : public IPC::MessageWithTuple< Tuple5<type1, type2, type3, type4, \
+                                             type5> > {                 \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \
+                const type3& arg3, const type4& arg4, const type5& arg5); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) \
   class msg_class : public IPC::MessageWithReply<Tuple0, Tuple0 > { \
-   public: \
-   enum { ID = msg_class##__ID }; \
-    msg_class() \
-        : IPC::MessageWithReply<Tuple0, Tuple0 >( \
-            MSG_ROUTING_CONTROL, ID, \
-            MakeTuple(), MakeTuple()) {} \
+    public:                                                         \
+      enum { ID = msg_class##__ID };                                \
+      msg_class();                                                  \
+      ~msg_class();                                                 \
+      static void Log(const Message* msg, std::wstring* l);         \
   };
 
-#define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) \
+#define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out)               \
   class msg_class : public IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> > { \
-   public: \
-   enum { ID = msg_class##__ID }; \
-    msg_class(type1_out* arg1) \
-        : IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> >( \
-            MSG_ROUTING_CONTROL, \
-            ID, \
-            MakeTuple(), MakeRefTuple(*arg1)) {} \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(type1_out* arg1);                                       \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(type1_out* arg1, type2_out* arg2) \
-        : IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> >( \
-            MSG_ROUTING_CONTROL, \
-            ID, \
-            MakeTuple(), MakeRefTuple(*arg1, *arg2)) {} \
+   msg_class(type1_out* arg1, type2_out* arg2);                         \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple0, \
           Tuple3<type1_out&, type2_out&, type3_out&> >{ \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(type1_out* arg1, type2_out* arg2, type3_out* arg3) \
-        : IPC::MessageWithReply<Tuple0,  \
-            Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \
-            ID, \
-            MakeTuple(), MakeRefTuple(*arg1, *arg2, *arg3)) {} \
+   msg_class(type1_out* arg1, type2_out* arg2, type3_out* arg3);    \
+   ~msg_class();                                                        \
+   static void Log(const Message* msg, std::wstring* l);                \
   };
 
-#define IPC_SYNC_MESSAGE_CONTROL1_0(msg_class, type1_in) \
-  class msg_class : \
-      public IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 > { \
-   public: \
-   enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 >( \
-            MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1), MakeTuple()) {} \
+#define IPC_SYNC_MESSAGE_CONTROL1_0(msg_class, type1_in)                \
+  class msg_class :                                                     \
+      public IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 > {         \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(const type1_in& arg1);                                  \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
-#define IPC_SYNC_MESSAGE_CONTROL1_1(msg_class, type1_in, type1_out) \
-  class msg_class : \
+#define IPC_SYNC_MESSAGE_CONTROL1_1(msg_class, type1_in, type1_out)     \
+  class msg_class :                                                     \
       public IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> > { \
-   public: \
-   enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, type1_out* arg2) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> >( \
-            MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1), MakeRefTuple(*arg2)) {} \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(const type1_in& arg1, type1_out* arg2);                 \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL1_2(msg_class, type1_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_out&> >( \
-            MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3)) {} \
+   msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3);   \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL1_3(msg_class, type1_in, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple1<type1_in>, \
           Tuple3<type1_out&, type2_out&, type3_out&> >{ \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3, type3_out* arg4) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, \
-            Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \
-            ID, \
-            MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3, *arg4)) {} \
+   msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3, type3_out* arg4); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
-#define IPC_SYNC_MESSAGE_CONTROL2_0(msg_class, type1_in, type2_in) \
-  class msg_class : \
+#define IPC_SYNC_MESSAGE_CONTROL2_0(msg_class, type1_in, type2_in)      \
+  class msg_class :                                                     \
       public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 > { \
-   public: \
-   enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2) \
-        : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 >( \
-            MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1, arg2), MakeTuple()) {} \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(const type1_in& arg1, const type2_in& arg2);            \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL2_1(msg_class, type1_in, type2_in, type1_out) \
-  class msg_class : \
+  class msg_class :                                                     \
       public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&> > { \
-   public: \
-   enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3) \
-        : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&> >( \
-            MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3)) {} \
+    public:                                                             \
+      enum { ID = msg_class##__ID };                                    \
+      msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL2_2(msg_class, type1_in, type2_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \
           Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_out* arg4) \
-        : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \
-            Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4)) {} \
+   msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_out* arg4); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL2_3(msg_class, type1_in, type2_in, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \
           Tuple3<type1_out&, type2_out&, type3_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_out* arg4, type3_out* arg5) \
-        : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \
-            Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \
-            ID, \
-            MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4, *arg5)) {} \
+   msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_out* arg4, type3_out* arg5); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL3_1(msg_class, type1_in, type2_in, type3_in, type1_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
           Tuple1<type1_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4) \
-        : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
-            Tuple1<type1_out&> >(MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4)) {} \
+   msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL3_2(msg_class, type1_in, type2_in, type3_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
           Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4, type2_out* arg5) \
-        : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
-            Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5)) {} \
+   msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4, type2_out* arg5); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL3_3(msg_class, type1_in, type2_in, type3_in, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
           Tuple3<type1_out&, type2_out&, type3_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4, type2_out* arg5, type3_out* arg6) \
-        : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
-            Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \
-            ID, \
-            MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5, *arg6)) {} \
+   msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4, type2_out* arg5, type3_out* arg6); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL4_1(msg_class, type1_in, type2_in, type3_in, type4_in, type1_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
           Tuple1<type1_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg6) \
-        : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
-            Tuple1<type1_out&> >(MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg6)) {} \
+   msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg6); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_CONTROL4_2(msg_class, type1_in, type2_in, type3_in, type4_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
           Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6) \
-        : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
-            Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg5, *arg6)) {} \
+   msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
+  };
+
+#define IPC_SYNC_MESSAGE_ROUTED0_0(msg_class) \
+  class msg_class : public IPC::MessageWithReply<Tuple0, Tuple0 > { \
+   public: \
+   enum { ID = msg_class##__ID }; \
+   msg_class(int routing_id);     \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED0_1(msg_class, type1_out) \
   class msg_class : public IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, type1_out* arg1) \
-        : IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> >( \
-            routing_id, ID, \
-            MakeTuple(), MakeRefTuple(*arg1)) {} \
-  };
-
-#define IPC_SYNC_MESSAGE_ROUTED0_0(msg_class) \
-  class msg_class : public IPC::MessageWithReply<Tuple0, Tuple0 > { \
-   public: \
-   enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id) \
-        : IPC::MessageWithReply<Tuple0, Tuple0 >( \
-            routing_id, ID, \
-            MakeTuple(), MakeTuple()) {} \
+   msg_class(int routing_id, type1_out* arg1);  \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED0_2(msg_class, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, type1_out* arg1, type2_out* arg2) \
-        : IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> >( \
-            routing_id, ID, \
-            MakeTuple(), MakeRefTuple(*arg1, *arg2)) {} \
+   msg_class(int routing_id, type1_out* arg1, type2_out* arg2); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED0_3(msg_class, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple0, \
           Tuple3<type1_out&, type2_out&, type3_out&> >{ \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, type1_out* arg1, type2_out* arg2, type3_out* arg3) \
-        : IPC::MessageWithReply<Tuple0,  \
-            Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \
-            MakeTuple(), MakeRefTuple(*arg1, *arg2, *arg3)) {} \
+   msg_class(int routing_id, type1_out* arg1, type2_out* arg2, type3_out* arg3); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED1_0(msg_class, type1_in) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 >( \
-            routing_id, ID, \
-            MakeRefTuple(arg1), MakeTuple()) {} \
+   msg_class(int routing_id, const type1_in& arg1); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED1_1(msg_class, type1_in, type1_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, type1_out* arg2) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> >( \
-            routing_id, ID, \
-            MakeRefTuple(arg1), MakeRefTuple(*arg2)) {} \
+   msg_class(int routing_id, const type1_in& arg1, type1_out* arg2);    \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED1_2(msg_class, type1_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* arg3) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_out&> >( \
-            routing_id, ID, \
-            MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3)) {} \
+   msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* arg3); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED1_3(msg_class, type1_in, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple1<type1_in>, \
           Tuple3<type1_out&, type2_out&, type3_out&> >{ \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* arg3, type3_out* arg4) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, \
-            Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3, *arg4)) {} \
+   msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* arg3, type3_out* arg4); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED1_4(msg_class, type1_in, type1_out, type2_out, type3_out, type4_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple1<type1_in>, \
           Tuple4<type1_out&, type2_out&, type3_out&, type4_out&> >{ \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* arg3, type3_out* arg4, type4_out* arg5) \
-        : IPC::MessageWithReply<Tuple1<type1_in>, \
-            Tuple4<type1_out&, type2_out&, type3_out&, type4_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3, *arg4, *arg5)) {} \
+   msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* arg3, type3_out* arg4, type4_out* arg5); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED2_0(msg_class, type1_in, type2_in) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2) \
-        : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 >( \
-            routing_id, ID, \
-            MakeRefTuple(arg1, arg2), MakeTuple()) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED2_1(msg_class, type1_in, type2_in, type1_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_out* arg3) \
-        : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&> >( \
-            routing_id, ID, \
-            MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_out* arg3); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED2_2(msg_class, type1_in, type2_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \
           Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_out* arg4) \
-        : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \
-            Tuple2<type1_out&, type2_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_out* arg4); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED2_3(msg_class, type1_in, type2_in, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \
           Tuple3<type1_out&, type2_out&, type3_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_out* arg4, type3_out* arg5) \
-        : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \
-            Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4, *arg5)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_out* arg4, type3_out* arg5); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED3_0(msg_class, type1_in, type2_in, type3_in) \
     class msg_class : \
       public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, Tuple0 > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3) \
-        : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, Tuple0>( \
-            routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3), MakeTuple()) {} \
-  };
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
+    };
 
 #define IPC_SYNC_MESSAGE_ROUTED3_1(msg_class, type1_in, type2_in, type3_in, type1_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
           Tuple1<type1_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4) \
-        : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
-            Tuple1<type1_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED3_2(msg_class, type1_in, type2_in, type3_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
           Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4, type2_out* arg5) \
-        : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
-            Tuple2<type1_out&, type2_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4, type2_out* arg5); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED3_3(msg_class, type1_in, type2_in, type3_in, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
           Tuple3<type1_out&, type2_out&, type3_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4, type2_out* arg5, type3_out* arg6) \
-        : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \
-            Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5, *arg6)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, type1_out* arg4, type2_out* arg5, type3_out* arg6); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED4_0(msg_class, type1_in, type2_in, type3_in, type4_in) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
           Tuple0 > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4) \
-        : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
-            Tuple0 >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4), MakeTuple()) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED4_1(msg_class, type1_in, type2_in, type3_in, type4_in, type1_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
           Tuple1<type1_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg6) \
-        : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
-            Tuple1<type1_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg6)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg6); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED4_2(msg_class, type1_in, type2_in, type3_in, type4_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
           Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6) \
-        : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
-            Tuple2<type1_out&, type2_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg5, *arg6)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED4_3(msg_class, type1_in, type2_in, type3_in, type4_in, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
           Tuple3<type1_out&, type2_out&, type3_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6, type3_out* arg7) \
-      : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \
-          Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \
-          MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg5, *arg6, *arg7)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6, type3_out* arg7); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED5_0(msg_class, type1_in, type2_in, type3_in, type4_in, type5_in) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, type5_in>, \
           Tuple0 > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, const type5_in& arg5) \
-        : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, type5_in>, \
-            Tuple0 >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeTuple()) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, const type5_in& arg5); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED5_1(msg_class, type1_in, type2_in, type3_in, type4_in, type5_in, type1_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, type5_in>, \
           Tuple1<type1_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, const type5_in& arg5, type1_out* arg6) \
-        : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, type5_in>, \
-            Tuple1<type1_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeRefTuple(*arg6)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, const type5_in& arg5, type1_out* arg6); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED5_2(msg_class, type1_in, type2_in, type3_in, type4_in, type5_in, type1_out, type2_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, type5_in>, \
           Tuple2<type1_out&, type2_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, const type4_in& arg5, type1_out* arg6, type2_out* arg7) \
-        : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, type5_in>, \
-            Tuple2<type1_out&, type2_out&> >(routing_id, ID, \
-            MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeRefTuple(*arg6, *arg7)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, const type4_in& arg5, type1_out* arg6, type2_out* arg7); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #define IPC_SYNC_MESSAGE_ROUTED5_3(msg_class, type1_in, type2_in, type3_in, type4_in, type5_in, type1_out, type2_out, type3_out) \
   class msg_class : \
       public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, type5_in>, \
           Tuple3<type1_out&, type2_out&, type3_out&> > { \
    public: \
    enum { ID = msg_class##__ID }; \
-    msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, const type4_in& arg5, type1_out* arg6, type2_out* arg7, type3_out* arg8) \
-      : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, type5_in>, \
-          Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \
-          MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeRefTuple(*arg6, *arg7, *arg8)) {} \
+   msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, const type4_in& arg4, const type4_in& arg5, type1_out* arg6, type2_out* arg7, type3_out* arg8); \
+      ~msg_class();                                                     \
+      static void Log(const Message* msg, std::wstring* l);             \
   };
 
 #endif  // #if defined()