Make printing work better with OOPIF. (try 2)

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 162 matching lines @@
 //     void OnSyncMessageName(const type1& in1, type2* out1, type3* out2)
 //
 // A caller can also send a synchronous message, while the receiver can respond
 // at a later time.  This is transparent from the sender's side.  The receiver
 // needs to use a different handler that takes in a IPC::Message* as the output
 // type, stash the message, and when it has the data it can Send the message.
 //
 // Use the IPC_MESSAGE_HANDLER_DELAY_REPLY macro instead of IPC_MESSAGE_HANDLER
 //     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_SyncMessageName,
 //                                     OnSyncMessageName)
+// Unlike IPC_MESSAGE_HANDLER which works with IPC_BEGIN_MESSAGE_MAP as well as
+// IPC_BEGIN_MESSAGE_MAP_WITH_PARAM, one needs to use
+// IPC_MESSAGE_HANDLER_WITH_PARAM_DELAY_REPLY to properly handle the param.
 //
 // The handler function will look like:
 //     void OnSyncMessageName(const type1& in1, IPC::Message* reply_msg);
 //
 // Receiver stashes the IPC::Message* pointer, and when it's ready, it does:
 //     ViewHostMsg_SyncMessageName::WriteReplyParams(reply_msg, out1, out2);
 //     Send(reply_msg);
 
 // Files that want to export their ipc messages should do
 //   #undef IPC_MESSAGE_EXPORT
@@ skipping 171 matching lines @@
         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)
 
+#define IPC_MESSAGE_FORWARD_WITH_PARAM_DELAY_REPLY(msg_class, obj,             \
+                                                   member_func)                \
+  case msg_class::ID: {                                                        \
+    TRACK_RUN_IN_THIS_SCOPED_REGION(member_func);                              \
+    if (!msg_class::DispatchWithParamDelayReply(&ipc_message__, obj, param__,  \
+                                                &member_func))                 \
+      ipc_message__.set_dispatch_error();                                      \
+  }                                                                            \
+  break;
+
+#define IPC_MESSAGE_HANDLER_WITH_PARAM_DELAY_REPLY(msg_class, member_func)     \
+    IPC_MESSAGE_FORWARD_WITH_PARAM_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)                           \
     case msg_class::ID: {                                                      \
         /* TRACK_RUN_IN_THIS_SCOPED_REGION(code);  TODO(jar) */                \
         code;                                                                  \
       }                                                                        \
       break;
 
 #define IPC_REPLY_HANDLER(func)                                                \
     case IPC_REPLY_ID: {                                                       \
@@ skipping 158 matching lines @@
   IPC_SYNC_MESSAGE_ROUTED(msg, (a, b, c, d, e), (f, g, h))
 #define IPC_SYNC_MESSAGE_ROUTED5_4(msg, a, b, c, d, e, f, g, h, i) \
   IPC_SYNC_MESSAGE_ROUTED(msg, (a, b, c, d, e), (f, g, h, i))
 
 #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