Create a message filter for message port messages. This allows a nice cleanu...

ipc/ipc_message_utils.h

 // Copyright (c) 2010 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.
 
 #ifndef IPC_IPC_MESSAGE_UTILS_H_
 #define IPC_IPC_MESSAGE_UTILS_H_
 #pragma once
 
 #include <algorithm>
 #include <string>
@@ skipping 903 matching lines @@
 
   // The constructor and the Read() method's templated implementations are in
   // ipc_message_utils_impl.h. The subclass constructor and Log() methods call
   // the templated versions of these and make sure there are instantiations in
   // those translation units.
   MessageWithTuple(int32 routing_id, uint32 type, const RefParam& p);
 
   static bool Read(const Message* msg, Param* p) IPC_MSG_NOINLINE;
 
   // Generic dispatcher.  Should cover most cases.
-  template<class T, class Method>
-  static bool Dispatch(const Message* msg, T* obj, Method func) {
+  template<class T, class S, class Method>
+  static bool Dispatch(const Message* msg, T* obj, S* sender, Method func) {
     Param p;
     if (Read(msg, &p)) {
       DispatchToMethod(obj, func, p);
       return true;
     }
     return false;
   }
 
   // The following dispatchers exist for the case where the callback function
   // needs the message as well.  They assume that "Param" is a type of Tuple
   // (except the one arg case, as there is no Tuple1).
-  template<class T, typename TA>
-  static bool Dispatch(const Message* msg, T* obj,
+  template<class T, class S, typename TA>
+  static bool Dispatch(const Message* msg, T* obj, S* sender,
                        void (T::*func)(const Message&, TA)) {
     Param p;
     if (Read(msg, &p)) {
       (obj->*func)(*msg, p.a);
       return true;
     }
     return false;
   }
 
-  template<class T, typename TA, typename TB>
-  static bool Dispatch(const Message* msg, T* obj,
+  template<class T, class S, typename TA, typename TB>
+  static bool Dispatch(const Message* msg, T* obj, S* sender,
                        void (T::*func)(const Message&, TA, TB)) {
     Param p;
     if (Read(msg, &p)) {
       (obj->*func)(*msg, p.a, p.b);
       return true;
     }
     return false;
   }
 
-  template<class T, typename TA, typename TB, typename TC>
-  static bool Dispatch(const Message* msg, T* obj,
+  template<class T, class S, typename TA, typename TB, typename TC>
+  static bool Dispatch(const Message* msg, T* obj, S* sender,
                        void (T::*func)(const Message&, TA, TB, TC)) {
     Param p;
     if (Read(msg, &p)) {
       (obj->*func)(*msg, p.a, p.b, p.c);
       return true;
     }
     return false;
   }
 
-  template<class T, typename TA, typename TB, typename TC, typename TD>
-  static bool Dispatch(const Message* msg, T* obj,
+  template<class T, class S, typename TA, typename TB, typename TC, typename TD>
+  static bool Dispatch(const Message* msg, T* obj, S* sender,
                        void (T::*func)(const Message&, TA, TB, TC, TD)) {
     Param p;
     if (Read(msg, &p)) {
       (obj->*func)(*msg, p.a, p.b, p.c, p.d);
       return true;
     }
     return false;
   }
 
-  template<class T, typename TA, typename TB, typename TC, typename TD,
+  template<class T, class S, typename TA, typename TB, typename TC, typename TD,
            typename TE>
-  static bool Dispatch(const Message* msg, T* obj,
+  static bool Dispatch(const Message* msg, T* obj, S* sender,
                        void (T::*func)(const Message&, TA, TB, TC, TD, TE)) {
     Param p;
     if (Read(msg, &p)) {
       (obj->*func)(*msg, p.a, p.b, p.c, p.d, p.e);
       return true;
     }
     return false;
   }
 
   // Functions used to do manual unpacking.  Only used by the automation code,
@@ skipping 113 matching lines @@
   typedef typename TupleTypes<SendParam>::ParamTuple RefSendParam;
   typedef ReplyParamType ReplyParam;
 
   MessageWithReply(int32 routing_id, uint32 type,
                    const RefSendParam& send, const ReplyParam& reply);
   static bool ReadSendParam(const Message* msg, SendParam* p) IPC_MSG_NOINLINE;
   static bool ReadReplyParam(
       const Message* msg,
       typename TupleTypes<ReplyParam>::ValueTuple* p) IPC_MSG_NOINLINE;
 
-  template<class T, class Method>
-  static bool Dispatch(const Message* msg, T* obj, Method func) {
+  template<class T, class S, class Method>
+  static bool Dispatch(const Message* msg, T* obj, S* sender, Method func) {
     SendParam send_params;
     Message* reply = GenerateReply(msg);
     bool error;
     if (ReadSendParam(msg, &send_params)) {
       typename TupleTypes<ReplyParam>::ValueTuple reply_params;
       DispatchToMethod(obj, func, send_params, &reply_params);
       WriteParam(reply, reply_params);
       error = false;
       LogReplyParamsToMessage(reply_params, msg);
     } else {
       NOTREACHED() << "Error deserializing message " << msg->type();
       reply->set_reply_error();
       error = true;
     }
 
-    obj->Send(reply);
+    sender->Send(reply);
     return !error;
   }
 
   template<class T, class Method>
   static bool DispatchDelayReply(const Message* msg, T* obj, Method func) {
     SendParam send_params;
     Message* reply = GenerateReply(msg);
     bool error;
     if (ReadSendParam(msg, &send_params)) {
       Tuple1<Message&> t = MakeRefTuple(*reply);
@@ skipping 38 matching lines @@
     ReplyParam p(a, b, c, d, e);
     WriteParam(reply, p);
   }
 };
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_MESSAGE_UTILS_H_