Decouple Media Service

ipc/ipc_message_templates.h

 // Copyright 2015 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_TEMPLATES_H_
 #define IPC_IPC_MESSAGE_TEMPLATES_H_
 
 #include <stdint.h>
 
 #include <type_traits>
@@ skipping 24 matching lines @@
                           const Tuple& tuple,
                           base::IndexSequence<Ns...>) {
   // TODO(mdempsky): Apply UnwrapTraits like base::DispatchToMethod?
   (obj->*method)(parameter, base::get<Ns>(tuple)...);
 }
 
 // The following function is for async IPCs which have a dispatcher with an
 // extra parameter specified using IPC_BEGIN_MESSAGE_MAP_WITH_PARAM.
 template <typename ObjT, typename P, typename... Args, typename... Ts>
 typename std::enable_if<sizeof...(Args) == sizeof...(Ts)>::type
 DispatchToMethod(ObjT* obj,

[danakj, 2016/03/03 21:01:40]

Or use this?

                  void (ObjT::*method)(P*, Args...),
                  P* parameter,
                  const base::Tuple<Ts...>& tuple) {
   DispatchToMethodImpl(obj, method, parameter, tuple,
                        base::MakeIndexSequence<sizeof...(Ts)>());
 }
 
 enum class MessageKind {
   CONTROL,
   ROUTED,
@@ skipping 103 matching lines @@
   static bool Dispatch(const Message* msg,
                        T* obj,
                        S* sender,
                        P* parameter,
                        Method func) {
     SendParam send_params;
     bool ok = ReadSendParam(msg, &send_params);
     Message* reply = SyncMessage::GenerateReply(msg);
     if (ok) {
       ReplyParam reply_params;
-      base::DispatchToMethod(obj, func, send_params, &reply_params);
+      base::DispatchToMethod(obj, func, parameter, send_params, &reply_params);
       WriteParam(reply, reply_params);
       LogReplyParamsToMessage(reply_params, msg);
     } else {
       NOTREACHED() << "Error deserializing message " << msg->type();
       reply->set_reply_error();
     }
     sender->Send(reply);
     return ok;
   }
 
   template <class T, class P, class Method>
   static bool DispatchDelayReply(const Message* msg,
                                  T* obj,
                                  P* parameter,
                                  Method func) {
     SendParam send_params;
     bool ok = ReadSendParam(msg, &send_params);
     Message* reply = SyncMessage::GenerateReply(msg);
     if (ok) {
       base::Tuple<Message&> t = base::MakeRefTuple(*reply);
       ConnectMessageAndReply(msg, reply);
-      base::DispatchToMethod(obj, func, send_params, &t);
+      base::DispatchToMethod(obj, func, parameter, send_params, &t);
     } else {
       NOTREACHED() << "Error deserializing message " << msg->type();
       reply->set_reply_error();
       obj->Send(reply);
     }
     return ok;
   }
 
  private:
   MessageT(Routing routing, const Ins&... ins, Outs*... outs);
 };
 
 }  // namespace IPC
 
 #if defined(IPC_MESSAGE_IMPL)
 #include "ipc/ipc_message_templates_impl.h"
 #endif
 
 #endif  // IPC_IPC_MESSAGE_TEMPLATES_H_