Standardize usage of virtual/override/final in ipc/

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 582 matching lines @@
     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);                                  \
-    virtual ~msg_class();                                                     \
+    ~msg_class() override;                                                    \
     static bool Read(const Message* msg, Schema::Param* p);                   \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
     IPC_ASYNC_MESSAGE_METHODS_##in_cnt                                        \
   };
 
-#define IPC_ASYNC_ROUTED_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(int32 routing_id IPC_COMMA_##in_cnt                             \
-              IPC_TYPE_IN_##in_cnt in_list);                                  \
-    virtual ~msg_class();                                                     \
-    static bool Read(const Message* msg, Schema::Param* p);                   \
-    static void Log(std::string* name, const Message* msg, std::string* l);   \
-    IPC_ASYNC_MESSAGE_METHODS_##in_cnt                                        \
+#define IPC_ASYNC_ROUTED_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(int32 routing_id                                               \
+                  IPC_COMMA_##in_cnt IPC_TYPE_IN_##in_cnt in_list);          \

[agl, 2014/10/21 17:49:49]

Please fix the indentation here and in other instances of this in the file.

[dcheng, 2014/10/21 17:57:44]

Sorry for missing this. I did spot check all the patches before CQing them. I'm
guessing IPC_COMMAND_##in_cnt throws off clang-format here.

+    ~msg_class() override;                                                   \
+    static bool Read(const Message* msg, Schema::Param* p);                  \
+    static void Log(std::string* name, const Message* msg, std::string* l);  \
+    IPC_ASYNC_MESSAGE_METHODS_##in_cnt                                       \
   };
 
-#define IPC_SYNC_CONTROL_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
-  class IPC_MESSAGE_EXPORT msg_class : public IPC::SyncMessage {              \
-   public:                                                                    \
-    typedef IPC::SyncMessageSchema<IPC_TUPLE_IN_##in_cnt in_list,             \
-                                   IPC_TUPLE_OUT_##out_cnt out_list> Schema;  \
-    typedef Schema::ReplyParam ReplyParam;                                    \
-    typedef Schema::SendParam SendParam;                                      \
-    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);                               \
-    virtual ~msg_class();                                                     \
-    static bool ReadSendParam(const Message* msg, Schema::SendParam* p);      \
-    static bool ReadReplyParam(                                               \
-        const Message* msg,                                                   \
-        TupleTypes<ReplyParam>::ValueTuple* p);                               \
-    static void Log(std::string* name, const Message* msg, std::string* l);   \
-    IPC_SYNC_MESSAGE_METHODS_##out_cnt                                        \
+#define IPC_SYNC_CONTROL_DECL(msg_class, in_cnt, out_cnt, in_list, out_list) \
+  class IPC_MESSAGE_EXPORT msg_class : public IPC::SyncMessage {             \
+   public:                                                                   \
+    typedef IPC::SyncMessageSchema<IPC_TUPLE_IN_##in_cnt in_list,            \
+                                   IPC_TUPLE_OUT_##out_cnt out_list> Schema; \
+    typedef Schema::ReplyParam ReplyParam;                                   \
+    typedef Schema::SendParam SendParam;                                     \
+    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() override;                                                   \
+    static bool ReadSendParam(const Message* msg, Schema::SendParam* p);     \
+    static bool ReadReplyParam(const Message* msg,                           \
+                               TupleTypes<ReplyParam>::ValueTuple* p);       \
+    static void Log(std::string* name, const Message* msg, std::string* l);  \
+    IPC_SYNC_MESSAGE_METHODS_##out_cnt                                       \
   };
 
-#define IPC_SYNC_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
-  class IPC_MESSAGE_EXPORT msg_class : public IPC::SyncMessage {              \
-   public:                                                                    \
-    typedef IPC::SyncMessageSchema<IPC_TUPLE_IN_##in_cnt in_list,             \
-                                   IPC_TUPLE_OUT_##out_cnt out_list> Schema;  \
-    typedef Schema::ReplyParam ReplyParam;                                    \
-    typedef Schema::SendParam SendParam;                                      \
-    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);                               \
-    virtual ~msg_class();                                                     \
-    static bool ReadSendParam(const Message* msg, Schema::SendParam* p);      \
-    static bool ReadReplyParam(                                               \
-        const Message* msg,                                                   \
-        TupleTypes<ReplyParam>::ValueTuple* p);                               \
-    static void Log(std::string* name, const Message* msg, std::string* l);   \
-    IPC_SYNC_MESSAGE_METHODS_##out_cnt                                        \
+#define IPC_SYNC_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
+  class IPC_MESSAGE_EXPORT msg_class : public IPC::SyncMessage {             \
+   public:                                                                   \
+    typedef IPC::SyncMessageSchema<IPC_TUPLE_IN_##in_cnt in_list,            \
+                                   IPC_TUPLE_OUT_##out_cnt out_list> Schema; \
+    typedef Schema::ReplyParam ReplyParam;                                   \
+    typedef Schema::SendParam SendParam;                                     \
+    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() override;                                                   \
+    static bool ReadSendParam(const Message* msg, Schema::SendParam* p);     \
+    static bool ReadReplyParam(const Message* msg,                           \
+                               TupleTypes<ReplyParam>::ValueTuple* p);       \
+    static void Log(std::string* name, const Message* msg, std::string* l);  \
+    IPC_SYNC_MESSAGE_METHODS_##out_cnt                                       \
   };
 
 #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,                              \
                           in_cnt, out_cnt, in_list, out_list)                 \
@@ skipping 305 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