Change common_message_generator code block.

ipc/ipc_message_macros.h

 // Copyright (c) 2011 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.
 
 // Defining IPC Messages
 //
 // Your IPC messages will be defined by macros inside of an XXX_messages.h
 // header file.  Most of the time, the system can automatically generate all
 // of messaging mechanism from these definitions, but sometimes some manual
 // coding is required.  In these cases, you will also have an XXX_messages.cc
@@ skipping 11 matching lines @@
 // each different message file.  Later, you will use this inside your
 // XXX_messages.h file before invoking message declatation macros:
 //     #define IPC_MESSAGE_START XXXMsgStart
 //       ( ... your macro invocations go here ... )
 //
 // Message Generator Files
 //
 // A message generator .h header file pulls in all other message-declaring
 // headers for a given component.  It is included by a message generator
 // .cc file, which is where all the generated code will wind up.  Typically,
-// you will use an existing generator (e.g. common_message_generator.cc and
-// common_message_generator.h in /chrome/common), but there are circumstances
-// where you may add a new one.
+// you will use an existing generator (e.g. common_message_generator.cc
+// in /chrome/common), but there are circumstances where you may add a
+// new one.
 //
 // In the rare cicrucmstances where you can't re-use an existing file,
 // your YYY_message_generator.cc file for a component YYY would contain
 // the following code:

[jam, 2011/03/11 23:19:53]

nit: it might be easier for people to copy it if C style comments were used
here.

 //     // Get basic type definitions.
 //     #define IPC_MESSAGE_IMPL
 //     #include "path/to/YYY_message_generator.h"
 //     // Generate constructors.
 //     #include "ipc/struct_constructor_macros.h"
 //     #include "path/to/YYY_message_generator.h"
 //     // Generate destructors.
 //     #include "ipc/struct_destructor_macros.h"
 //     #include "path/to/YYY_message_generator.h"
-//     namespace IPC {
 //     // Generate param traits write methods.
 //     #include "ipc/param_traits_write_macros.h"
+//     namespace IPC {
 //     #include "path/to/YYY_message_generator.h"
+//     }  // namespace IPC
 //     // Generate param traits read methods.
 //     #include "ipc/param_traits_read_macros.h"
+//     namespace IPC {
 //     #include "path/to/YYY_message_generator.h"
+//     }  // namespace IPC
 //     // Generate param traits log methods.
 //     #include "ipc/param_traits_log_macros.h"
+//     namespace IPC {
 //     #include "path/to/YYY_message_generator.h"
 //     }  // namespace IPC
 //
 // In cases where manual generation is required, in your XXX_messages.cc
 // file, put the following after all the includes for param types:
 //     #define IPC_MESSAGE_IMPL
 //     #include "XXX_messages.h"
 //        (... implementation of traits not auto-generated ...)
 //
 // Multiple Inclusion
@@ skipping 112 matching lines @@
   struct struct_name; \
   IPC_STRUCT_TRAITS_BEGIN(struct_name) \
   IPC_STRUCT_TRAITS_END() \
   struct struct_name : IPC::NoParams { \
     struct_name(); \
     ~struct_name();
 #define IPC_STRUCT_MEMBER(type, name) type name;
 #define IPC_STRUCT_END() };
 
 // Message macros collect specific numbers of arguments and funnel them into
-// the common message generation macro.
+// the common message generation macro.  These should never be redefined.
 #define IPC_MESSAGE_CONTROL0(msg_class) \
   IPC_MESSAGE_DECL(EMPTY, CONTROL, msg_class, 0, 0, (), ())
 
 #define IPC_MESSAGE_CONTROL1(msg_class, type1) \
   IPC_MESSAGE_DECL(ASYNC, CONTROL, msg_class, 1, 0, (type1), ())
 
 #define IPC_MESSAGE_CONTROL2(msg_class, type1, type2) \
   IPC_MESSAGE_DECL(ASYNC, CONTROL, msg_class, 2, 0, (type1, type2), ())
 
 #define IPC_MESSAGE_CONTROL3(msg_class, type1, type2, type3) \
@@ skipping 199 matching lines @@
 
 #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_DECL(SYNC, ROUTED, msg_class, 5, 3, (type1_in, type2_in, type3_in, type4_in, type5_in), (type1_out, type2_out, type3_out))
 
 #define IPC_SYNC_MESSAGE_ROUTED5_4(msg_class, type1_in, type2_in, type3_in, type4_in, type5_in, type1_out, type2_out, type3_out, type4_out) \
   IPC_MESSAGE_DECL(SYNC, ROUTED, msg_class, 5, 4, (type1_in, type2_in, type3_in, type4_in, type5_in), (type1_out, type2_out, type3_out, type4_out))
 
 // Common message macro which dispatches into one of the 6 (sync x kind)
 // routines.  There is a way that these 6 cases can be lumped together,
 // but the  macros get very complicated in that case.
-// Note: we currently use __LINE__ to give unique IDs to messages within
-// a file.  They're globally unique since each file defines its own
-// IPC_MESSAGE_START.  Ideally, we wouldn't use line numbers (a possibility
-// is to instead use the __COUNTER__ macro, but it needs gcc 4.3 and xcode
-// doesn't use it yet).
+// Note: intended be redefined to generate other information.
 #define IPC_MESSAGE_DECL(sync, kind, msg_class,                               \
                          in_cnt, out_cnt, in_list, out_list)                  \
   IPC_##sync##_##kind##_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
   IPC_MESSAGE_EXTRA(sync, kind, msg_class, in_cnt, out_cnt, in_list, out_list)
 
 #define IPC_EMPTY_CONTROL_DECL(msg_class, in_cnt, out_cnt, in_list, out_list) \
   class msg_class : public IPC::Message {                                     \
    public:                                                                    \
-    enum { ID = (IPC_MESSAGE_START << 16) + __LINE__ };                       \
+    enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class() : IPC::Message(MSG_ROUTING_CONTROL, ID, PRIORITY_NORMAL) {}   \
   };
 
 #define IPC_EMPTY_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   class msg_class : public IPC::Message {                                     \
    public:                                                                    \
-    enum { ID = (IPC_MESSAGE_START << 16) + __LINE__ };                       \
+    enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(int32 routing_id)                                               \
         : IPC::Message(routing_id, ID, PRIORITY_NORMAL) {}                    \
   };
 
 #define IPC_ASYNC_CONTROL_DECL(msg_class, in_cnt, out_cnt, in_list, out_list) \
   class msg_class :                                                           \
       public IPC::MessageWithTuple<IPC_TUPLE_IN_##in_cnt in_list> {           \
    public:                                                                    \
-    enum { ID = (IPC_MESSAGE_START << 16) + __LINE__ };                       \
+    enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(IPC_TYPE_IN_##in_cnt in_list);                                  \
     ~msg_class();                                                             \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #define IPC_ASYNC_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   class msg_class :                                                           \
       public IPC::MessageWithTuple<IPC_TUPLE_IN_##in_cnt in_list> {           \
    public:                                                                    \
-    enum { ID = (IPC_MESSAGE_START << 16) + __LINE__ };                       \
+    enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(int32 routing_id IPC_COMMA_##in_cnt                             \
               IPC_TYPE_IN_##in_cnt in_list);                                  \
     ~msg_class();                                                             \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #define IPC_SYNC_CONTROL_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   class msg_class :                                                           \
       public IPC::MessageWithReply<IPC_TUPLE_IN_##in_cnt in_list,             \
                                    IPC_TUPLE_OUT_##out_cnt out_list> {        \
    public:                                                                    \
-    enum { ID = (IPC_MESSAGE_START << 16) + __LINE__ };                       \
+    enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(IPC_TYPE_IN_##in_cnt in_list                                    \
               IPC_COMMA_AND_##in_cnt(IPC_COMMA_##out_cnt)                     \
               IPC_TYPE_OUT_##out_cnt out_list);                               \
     ~msg_class();                                                             \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #define IPC_SYNC_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
   class msg_class :                                                           \
       public IPC::MessageWithReply<IPC_TUPLE_IN_##in_cnt in_list,             \
                                    IPC_TUPLE_OUT_##out_cnt out_list> {        \
    public:                                                                    \
-    enum { ID = (IPC_MESSAGE_START << 16) + __LINE__ };                       \
+    enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(int32 routing_id                                                \
               IPC_COMMA_OR_##in_cnt(IPC_COMMA_##out_cnt)                      \
               IPC_TYPE_IN_##in_cnt in_list                                    \
               IPC_COMMA_AND_##in_cnt(IPC_COMMA_##out_cnt)                     \
               IPC_TYPE_OUT_##out_cnt out_list);                               \
     ~msg_class();                                                             \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #if defined(IPC_MESSAGE_IMPL)
@@ skipping 180 matching lines @@
 #define IPC_COMMA_AND_4(x) x
 #define IPC_COMMA_AND_5(x) x
 
 #define IPC_COMMA_OR_0(x) x
 #define IPC_COMMA_OR_1(x) ,
 #define IPC_COMMA_OR_2(x) ,
 #define IPC_COMMA_OR_3(x) ,
 #define IPC_COMMA_OR_4(x) ,
 #define IPC_COMMA_OR_5(x) ,
 
+// Message IDs
+// Note: we currently use __LINE__ to give unique IDs to messages within
+// a file.  They're globally unique since each file defines its own
+// IPC_MESSAGE_START.  Ideally, we wouldn't use line numbers (a possibility
+// is to instead use the __COUNTER__ macro, but it needs gcc 4.3 and xcode
+// doesn't use it yet).
+#define IPC_MESSAGE_ID() ((IPC_MESSAGE_START << 16) + __LINE__)
+#define IPC_MESSAGE_ID_CLASS(id) ((id) >> 16)
+#define IPC_MESSAGE_ID_LINE(id) ((id) & 0xffff)
+
 // Message crackers and handlers.
 // Prefer to use the IPC_BEGIN_MESSAGE_MAP_EX to the older macros since they
 // allow you to detect when a message could not be de-serialized. Usage:
 //
 //   bool MyClass::OnMessageReceived(const IPC::Message& msg) {
 //     bool handled = true;
 //     bool msg_is_good = false;
 //     IPC_BEGIN_MESSAGE_MAP_EX(MyClass, msg, msg_is_good)
 //       IPC_MESSAGE_HANDLER(MsgClassOne, OnMsgClassOne)
 //       ...more handlers here ...
@@ skipping 63 matching lines @@
     DCHECK(msg_is_ok__); \
   } \
 }
 
 #define IPC_END_MESSAGE_MAP_EX() \
   } \
 }
 
 // This corresponds to an enum value from IPCMessageStart.
 #define IPC_MESSAGE_CLASS(message) \
-  message.type() >> 16
+  IPC_MESSAGE_ID_CLASS(message.type())
 
 #endif  // IPC_IPC_MESSAGE_MACROS_H_
 
 // Clean up IPC_MESSAGE_START in this unguarded section so that the
 // XXX_messages.h files need not do so themselves.  This makes the
 // XXX_messages.h files easier to write.
 #undef IPC_MESSAGE_START