Make it easier to create new IPC channel types (i.e. renderer/plugin). Inste...

chrome/common/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 23 matching lines @@
 //
 // The handler function will look like:
 //     void OnSyncMessageName(const type1& in1, IPC::Message* reply_msg);
 //
 // Receiver stashes the IPC::Message* pointer, and when it's ready, it does:
 //     ViewHostMsg_SyncMessageName::WriteReplyParams(reply_msg, out1, out2);
 //     Send(reply_msg);
 
 #include "chrome/common/ipc_message_utils.h"
 
+
+#ifndef MESSAGES_INTERNAL_FILE
+#error This file should only be included by X_messages.h, which needs to define MESSAGES_INTERNAL_FILE first.
+#endif
+
+#ifndef IPC_MESSAGE_MACROS_INCLUDE_BLOCK
+#define IPC_MESSAGE_MACROS_INCLUDE_BLOCK
+
+// Multi-pass include of X_messages_internal.h.  Preprocessor magic allows
+// us to use 1 header to define the enums and classes for our render messages.
+#define IPC_MESSAGE_MACROS_ENUMS
+#include MESSAGES_INTERNAL_FILE
+
+#define IPC_MESSAGE_MACROS_CLASSES
+#include MESSAGES_INTERNAL_FILE
+
+#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
+
+
 // 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_MESSAGE_ROUTED6
-#undef IPC_MESSAGE_EMPTY
 #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
@@ skipping 16 matching lines @@
 #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
 
+
 #if defined(IPC_MESSAGE_MACROS_ENUMS)
 #undef IPC_MESSAGE_MACROS_ENUMS
 
 // TODO(jabdelmalek): we're using the lowest 12 bits of type for the message
 // id, and the highest 4 bits for the channel type.  This constrains us to
 // 16 channel types (currently using 8) and 4K messages per type.  Should
 // really make type be 32 bits, but then we break automation with older Chrome
 // builds..
-#define IPC_BEGIN_MESSAGES(label, start) \
+
+#define IPC_BEGIN_MESSAGES(label) \
   enum label##MsgType { \
-  label##Start = start << 12, \
-  label##PreStart = (start << 12) - 1,  // Do this so that automation messages keep the same id as before
+  label##Start = label##MsgStart << 12, \
+  label##PreStart = (label##MsgStart << 12) - 1,  // Do this so that automation messages keep the same id as before
 
 #define IPC_END_MESSAGES(label) \
   label##End \
   };
 
 #define IPC_MESSAGE_CONTROL0(msg_class) \
   msg_class##__ID,
 
 #define IPC_MESSAGE_CONTROL1(msg_class, type1) \
   msg_class##__ID,
@@ skipping 24 matching lines @@
 
 #define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4) \
   msg_class##__ID,
 
 #define IPC_MESSAGE_ROUTED5(msg_class, type1, type2, type3, type4, type5) \
   msg_class##__ID,
 
 #define IPC_MESSAGE_ROUTED6(msg_class, type1, type2, type3, type4, type5, type6) \
   msg_class##__ID,
 
-#define IPC_MESSAGE_EMPTY(msg_class) \
-  msg_class##__ID,
-
 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) \
   msg_class##__ID,
 
 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) \
   msg_class##__ID,
 
 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) \
   msg_class##__ID,
 
 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, type3_out) \
@@ skipping 168 matching lines @@
   } \
 }
 
 #define IPC_END_MESSAGE_MAP_EX() \
   } \
 }
 
 #elif defined(IPC_MESSAGE_MACROS_LOG)
 #undef IPC_MESSAGE_MACROS_LOG
 
-#define IPC_BEGIN_MESSAGES(label, start) \
+#define IPC_BEGIN_MESSAGES(label) \
   void label##MsgLog(uint16 type, std::wstring* name, const IPC::Message* msg, std::wstring* params) { \
   switch (type) {
 
 #define IPC_END_MESSAGES(label) \
      default: \
       if (name) \
         *name = L"[UNKNOWN " L ## #label L" MSG"; \
     } \
   }
 
@@ skipping 37 matching lines @@
 
 #define IPC_MESSAGE_ROUTED4(msg_class, type1, type2, type3, type4) \
   IPC_MESSAGE_LOG(msg_class)
 
 #define IPC_MESSAGE_ROUTED5(msg_class, type1, type2, type3, type4, type5) \
   IPC_MESSAGE_LOG(msg_class)
 
 #define IPC_MESSAGE_ROUTED6(msg_class, type1, type2, type3, type4, type5, type6) \
   IPC_MESSAGE_LOG(msg_class)
 
-#define IPC_MESSAGE_EMPTY(msg_class) \
-  IPC_MESSAGE_LOG(msg_class)
-
 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) \
   IPC_MESSAGE_LOG(msg_class)
 
 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) \
   IPC_MESSAGE_LOG(msg_class)
 
 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) \
   IPC_MESSAGE_LOG(msg_class)
 
 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, type3_out) \
@@ skipping 88 matching lines @@
 
 #define IPC_SYNC_MESSAGE_ROUTED4_0(msg_class, type1_in, type2_in, type3_in, type4_in) \
   IPC_MESSAGE_LOG(msg_class)
 
 #define IPC_SYNC_MESSAGE_ROUTED4_1(msg_class, type1_in, type2_in, type3_in, type4_in, type1_out) \
   IPC_MESSAGE_LOG(msg_class)
 
 #elif defined(IPC_MESSAGE_MACROS_CLASSES)
 #undef IPC_MESSAGE_MACROS_CLASSES
 
-#define IPC_BEGIN_MESSAGES(label, start)
+#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) {} \
@@ skipping 124 matching lines @@
  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,  \
               const type6& arg6)                                        \
       : IPC::MessageWithTuple< Tuple6<type1, type2, type3, type4, type5, \
       type6> >(                                                         \
           routing_id, ID, MakeTuple(arg1, arg2, arg3, arg4, arg5, arg6)) {} \
   };
 
-// Dummy class for now, just to give us the ID field.
-#define IPC_MESSAGE_EMPTY(msg_class) \
-  class msg_class { \
-   public: \
-    enum { ID = msg_class##__ID }; \
-    static void Log(const IPC::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()) {} \
   };
 
@@ skipping 387 matching lines @@
    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, \
             MakeTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg6)) {} \
   };
 
 #endif  // #if defined()