Remove IPC_BEGIN_MESSAGE_MAP_EX macro since r270839 made all bad IPCs kill their child processes.

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 858 matching lines @@
 #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.
 #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:
+// Message crackers and handlers. 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_BEGIN_MESSAGE_MAP(MyClass, msg)
 //       IPC_MESSAGE_HANDLER(MsgClassOne, OnMsgClassOne)
 //       ...more handlers here ...
 //       IPC_MESSAGE_HANDLER(MsgClassTen, OnMsgClassTen)
 //       IPC_MESSAGE_UNHANDLED(handled = false)
-//     IPC_END_MESSAGE_MAP_EX()
-//     if (!msg_is_good) {
-//       // Signal error here or terminate offending process.
-//     }
+//     IPC_END_MESSAGE_MAP()
 //     return handled;
 //   }
 
 
-#define IPC_BEGIN_MESSAGE_MAP_EX(class_name, msg, msg_is_ok) \
-  { \
-    typedef class_name _IpcMessageHandlerClass; \
-    void* param__ = NULL; \
-    const IPC::Message& ipc_message__ = msg; \
-    bool& msg_is_ok__ = msg_is_ok; \
-    switch (ipc_message__.type()) {
-
 #define IPC_BEGIN_MESSAGE_MAP(class_name, msg) \
   { \
     typedef class_name _IpcMessageHandlerClass; \
     void* param__ = NULL; \
     const IPC::Message& ipc_message__ = msg; \
-    bool msg_is_ok__ = true; \
     switch (ipc_message__.type()) {
 
 // gcc gives the following error now when using decltype so type typeof there:
 //   error: identifier 'decltype' will become a keyword in C++0x [-Werror=c++0x-compat]
 #if defined(OS_WIN)
 #define IPC_DECLTYPE decltype
 #else
 #define IPC_DECLTYPE typeof
 #endif
 
-#define IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(class_name, msg, msg_is_ok, param)    \
+#define IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(class_name, msg, param)               \
   {                                                                            \
     typedef class_name _IpcMessageHandlerClass;                                \
     IPC_DECLTYPE(param) param__ = param;                                       \
     const IPC::Message& ipc_message__ = msg;                                   \
-    bool& msg_is_ok__ = msg_is_ok;                                             \
     switch (ipc_message__.type()) {
 
 #define IPC_MESSAGE_FORWARD(msg_class, obj, member_func)                       \
     case msg_class::ID: {                                                      \
         TRACK_RUN_IN_IPC_HANDLER(member_func);                                 \
-        msg_is_ok__ = msg_class::Dispatch(&ipc_message__, obj, this,           \
-                                          param__, &member_func);              \
-        if (!msg_is_ok__)                                                      \
+        if (!msg_class::Dispatch(&ipc_message__, obj, this, param__,           \
+                                 &member_func))                                \
           ipc_message__.set_dispatch_error();                                  \
       }                                                                        \
       break;
 
 #define IPC_MESSAGE_HANDLER(msg_class, member_func) \
   IPC_MESSAGE_FORWARD(msg_class, this, _IpcMessageHandlerClass::member_func)
 
 #define IPC_MESSAGE_FORWARD_DELAY_REPLY(msg_class, obj, member_func)           \
     case msg_class::ID: {                                                      \
         TRACK_RUN_IN_IPC_HANDLER(member_func);                                 \
-        msg_is_ok__ = msg_class::DispatchDelayReply(&ipc_message__, obj,       \
-                                                  param__, &member_func);      \
-        if (!msg_is_ok__)                                                      \
+        if (!msg_class::DispatchDelayReply(&ipc_message__, obj, param__,       \
+                                           &member_func))                      \
           ipc_message__.set_dispatch_error();                                  \
       }                                                                        \
       break;
 
 #define IPC_MESSAGE_HANDLER_DELAY_REPLY(msg_class, member_func)                \
     IPC_MESSAGE_FORWARD_DELAY_REPLY(msg_class, this,                           \
                                     _IpcMessageHandlerClass::member_func)
 
 // TODO(jar): fix chrome frame to always supply |code| argument.
 #define IPC_MESSAGE_HANDLER_GENERIC(msg_class, code)                           \
@@ skipping 17 matching lines @@
       }                                                                        \
       break;
 
 #define IPC_MESSAGE_UNHANDLED_ERROR() \
   IPC_MESSAGE_UNHANDLED(NOTREACHED() << \
                               "Invalid message with type = " << \
                               ipc_message__.type())
 
 #define IPC_END_MESSAGE_MAP() \
   } \
-  DCHECK(msg_is_ok__); \
-}
-
-#define IPC_END_MESSAGE_MAP_EX() \
-  } \
 }
 
 // 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_
 
 // The following #ifdef cannot be removed.  Although the code is semantically
 // 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