Introduce ResourceRequesterInfo to abstract the requester of resource request

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 <tuple>
@@ skipping 34 matching lines @@
 template <typename ObjT, typename P, typename... Args, typename... Ts>
 typename std::enable_if<sizeof...(Args) == sizeof...(Ts)>::type
 DispatchToMethod(ObjT* obj,
                  void (ObjT::*method)(P*, Args...),
                  P* parameter,
                  const std::tuple<Ts...>& tuple) {
   DispatchToMethodImpl(obj, method, parameter, tuple,
                        base::MakeIndexSequence<sizeof...(Ts)>());
 }
 
+// This function is for all the sync IPCs that don't pass an extra parameter
+// using IPC_BEGIN_MESSAGE_MAP_WITH_PARAM.
+template <typename ObjT,
+          typename Method,
+          typename P,
+          typename Tuple,
+          typename ReplyParam>
+void DispatchToSyncMethod(ObjT* obj,
+                          Method method,
+                          P*,
+                          const Tuple& tuple,
+                          ReplyParam* reply) {
+  base::DispatchToMethod(obj, method, tuple, reply);
+}
+
+template <typename ObjT,
+          typename Method,
+          typename P,
+          typename InTuple,
+          typename OutTuple,
+          size_t... InNs,
+          size_t... OutNs>
+inline void DispatchToSyncMethodImpl(const ObjT& obj,
+                                     Method method,
+                                     P* parameter,
+                                     InTuple&& in,
+                                     OutTuple* out,
+                                     base::IndexSequence<InNs...>,
+                                     base::IndexSequence<OutNs...>) {
+  (obj->*method)(parameter, base::get<InNs>(std::forward<InTuple>(in))...,
+                 &std::get<OutNs>(*out)...);
+}
+
+// The following function is for sync 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... InParam,
+          typename... OutParam>
+typename std::enable_if<sizeof...(Args) ==
+                        sizeof...(InParam) + sizeof...(OutParam)>::type
+DispatchToSyncMethod(ObjT* obj,
+                     void (ObjT::*method)(P*, Args...),
+                     P* parameter,
+                     const std::tuple<InParam...>& in,
+                     std::tuple<OutParam...>* out) {
+  DispatchToSyncMethodImpl(obj, method, parameter, in, out,
+                           base::MakeIndexSequence<sizeof...(InParam)>(),
+                           base::MakeIndexSequence<sizeof...(OutParam)>());
+}
+
 enum class MessageKind {
   CONTROL,
   ROUTED,
 };
 
 // Routing is a helper struct so MessageT's private common constructor has a
 // different type signature than the public "int32_t routing_id" one.
 struct Routing {
   explicit Routing(int32_t id) : id(id) {}
   int32_t id;
@@ skipping 98 matching lines @@
                        T* obj,
                        S* sender,
                        P* parameter,
                        Method func) {
     TRACE_EVENT0("ipc", Meta::kName);
     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);
+      DispatchToSyncMethod(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) {
     TRACE_EVENT0("ipc", Meta::kName);
     SendParam send_params;
     bool ok = ReadSendParam(msg, &send_params);
     Message* reply = SyncMessage::GenerateReply(msg);
     if (ok) {
       std::tuple<Message&> t = std::tie(*reply);
       ConnectMessageAndReply(msg, reply);
-      base::DispatchToMethod(obj, func, send_params, &t);
+      DispatchToSyncMethod(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_