Virtual destructors should have virtual keyword.

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 424 matching lines @@
     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_ID() };                                           \
     msg_class(IPC_TYPE_IN_##in_cnt in_list);                                  \
-    ~msg_class();                                                             \
+    virtual ~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_ID() };                                           \
     msg_class(int32 routing_id IPC_COMMA_##in_cnt                             \
               IPC_TYPE_IN_##in_cnt in_list);                                  \
-    ~msg_class();                                                             \
+    virtual ~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_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();                                                             \
+    virtual ~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_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();                                                             \
+    virtual ~msg_class();                                                     \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #if defined(IPC_MESSAGE_IMPL)
 
 // "Implementation" inclusion produces constructors, destructors, and
 // logging functions, except for the no-arg special cases, where the
 // implementation occurs in the declaration, and there is no special
 // logging function.
 #define IPC_MESSAGE_EXTRA(sync, kind, msg_class,                              \
@@ skipping 275 matching lines @@
 // This corresponds to an enum value from IPCMessageStart.
 #define IPC_MESSAGE_CLASS(message) \
   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
-