Remove unused IPC::Message priority.

ipc/ipc_message_macros.h

 // Copyright (c) 2012 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 596 matching lines @@
 #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 IPC_MESSAGE_EXPORT msg_class : public IPC::Message {                  \
    public:                                                                    \
     typedef IPC::Message Schema;                                              \
     enum { ID = IPC_MESSAGE_ID() };                                           \
-    msg_class() : IPC::Message(MSG_ROUTING_CONTROL, ID, PRIORITY_NORMAL) {}   \
+    msg_class() : IPC::Message(MSG_ROUTING_CONTROL, ID) {}                    \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #define IPC_EMPTY_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   class IPC_MESSAGE_EXPORT msg_class : public IPC::Message {                  \
    public:                                                                    \
     typedef IPC::Message Schema;                                              \
     enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(int32 routing_id)                                               \
-        : IPC::Message(routing_id, ID, PRIORITY_NORMAL) {}                    \
+        : IPC::Message(routing_id, ID) {}                                     \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #define IPC_ASYNC_CONTROL_DECL(msg_class, in_cnt, out_cnt, in_list, out_list) \
   class IPC_MESSAGE_EXPORT msg_class : public IPC::Message {                  \
    public:                                                                    \
     typedef IPC::MessageSchema<IPC_TUPLE_IN_##in_cnt in_list> Schema;         \
     typedef Schema::Param Param;                                              \
     enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(IPC_TYPE_IN_##in_cnt in_list);                                  \
@@ skipping 68 matching lines @@
 #define IPC_MESSAGE_EXTRA(sync, kind, msg_class,                              \
                           in_cnt, out_cnt, in_list, out_list)                 \
   IPC_##sync##_##kind##_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
   IPC_##sync##_MESSAGE_LOG(msg_class)
 
 #define IPC_EMPTY_CONTROL_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)
 #define IPC_EMPTY_ROUTED_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)
 
 #define IPC_ASYNC_CONTROL_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list) \
   msg_class::msg_class(IPC_TYPE_IN_##in_cnt in_list) :                        \
-      IPC::Message(MSG_ROUTING_CONTROL, ID, PRIORITY_NORMAL) {                \
+      IPC::Message(MSG_ROUTING_CONTROL, ID) {                                 \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::Read(const Message* msg, Schema::Param* p) {                \
     return Schema::Read(msg, p);                                              \
   }
 
 #define IPC_ASYNC_ROUTED_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   msg_class::msg_class(int32 routing_id IPC_COMMA_##in_cnt                    \
                        IPC_TYPE_IN_##in_cnt in_list) :                        \
-      IPC::Message(routing_id, ID, PRIORITY_NORMAL) {                         \
+      IPC::Message(routing_id, ID) {                                          \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::Read(const Message* msg, Schema::Param* p) {                \
     return Schema::Read(msg, p);                                              \
   }
 
 #define IPC_SYNC_CONTROL_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   msg_class::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) :                     \
-      IPC::SyncMessage(MSG_ROUTING_CONTROL, ID, PRIORITY_NORMAL,              \
+      IPC::SyncMessage(MSG_ROUTING_CONTROL, ID,                               \
                        new IPC::ParamDeserializer<Schema::ReplyParam>(        \
                            IPC_NAME_OUT_##out_cnt out_list)) {                \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::ReadSendParam(const Message* msg, Schema::SendParam* p) {   \
     return Schema::ReadSendParam(msg, p);                                     \
   }                                                                           \
   bool msg_class::ReadReplyParam(const Message* msg,                          \
                                  TupleTypes<ReplyParam>::ValueTuple* p) {     \
     return Schema::ReadReplyParam(msg, p);                                    \
   }
 
 #define IPC_SYNC_ROUTED_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
   msg_class::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) :                     \
-      IPC::SyncMessage(routing_id, ID, PRIORITY_NORMAL,                       \
+      IPC::SyncMessage(routing_id, ID,                                        \
                        new IPC::ParamDeserializer<Schema::ReplyParam>(        \
                            IPC_NAME_OUT_##out_cnt out_list)) {                \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::ReadSendParam(const Message* msg, Schema::SendParam* p) {   \
     return Schema::ReadSendParam(msg, p);                                     \
   }                                                                           \
   bool msg_class::ReadReplyParam(const Message* msg,                          \
                                  TupleTypes<ReplyParam>::ValueTuple* p) {     \
@@ skipping 244 matching lines @@
 // equivalent without the #ifdef, VS2013 contains a bug where it is
 // over-aggressive in optimizing out #includes.  Putting the #ifdef is a
 // workaround for this bug.  See http://goo.gl/eGt2Fb for more details.
 // This can be removed once VS2013 is fixed.
 #ifdef IPC_MESSAGE_START
 // 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
 #endif