mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 1 | // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #ifndef IPC_IPC_MESSAGE_TEMPLATES_H_ |
| 6 | #define IPC_IPC_MESSAGE_TEMPLATES_H_ |
| 7 | |
| 8 | #include <stdint.h> |
| 9 | |
tzik | a088e35 | 2016-03-08 14:47:44 +0900 | [diff] [blame] | 10 | #include <tuple> |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 11 | #include <type_traits> |
Jeremy Roman | 773e7f2 | 2017-08-17 00:55:20 +0900 | [diff] [blame] | 12 | #include <utility> |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 13 | |
| 14 | #include "base/logging.h" |
ssid | 49c4822 | 2016-03-29 04:56:49 +0900 | [diff] [blame] | 15 | #include "base/trace_event/trace_event.h" |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 16 | #include "base/tuple.h" |
| 17 | #include "build/build_config.h" |
| 18 | #include "ipc/ipc_message.h" |
| 19 | #include "ipc/ipc_message_utils.h" |
| 20 | |
| 21 | namespace IPC { |
| 22 | |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 23 | template <typename Tuple, size_t... Ns> |
| 24 | auto TupleForwardImpl(Tuple&& tuple, std::index_sequence<Ns...>) -> decltype( |
| 25 | std::forward_as_tuple(std::get<Ns>(std::forward<Tuple>(tuple))...)) { |
| 26 | return std::forward_as_tuple(std::get<Ns>(std::forward<Tuple>(tuple))...); |
| 27 | } |
| 28 | |
| 29 | // Transforms std::tuple contents to the forwarding form. |
| 30 | // Example: |
| 31 | // std::tuple<int, int&, const int&, int&&>&& |
| 32 | // -> std::tuple<int&&, int&, const int&, int&&>. |
| 33 | // const std::tuple<int, const int&, int&&>& |
| 34 | // -> std::tuple<const int&, int&, const int&, int&>. |
| 35 | // |
| 36 | // TupleForward(std::make_tuple(a, b, c)) is equivalent to |
| 37 | // std::forward_as_tuple(a, b, c). |
| 38 | template <typename Tuple> |
| 39 | auto TupleForward(Tuple&& tuple) -> decltype(TupleForwardImpl( |
| 40 | std::forward<Tuple>(tuple), |
| 41 | std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>())) { |
| 42 | return TupleForwardImpl( |
| 43 | std::forward<Tuple>(tuple), |
| 44 | std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>()); |
| 45 | } |
| 46 | |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 47 | // This function is for all the async IPCs that don't pass an extra parameter |
| 48 | // using IPC_BEGIN_MESSAGE_MAP_WITH_PARAM. |
| 49 | template <typename ObjT, typename Method, typename P, typename Tuple> |
tzik | d140291 | 2017-08-30 22:39:03 +0900 | [diff] [blame] | 50 | void DispatchToMethod(ObjT* obj, Method method, P*, Tuple&& tuple) { |
| 51 | base::DispatchToMethod(obj, method, std::forward<Tuple>(tuple)); |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | template <typename ObjT, |
| 55 | typename Method, |
| 56 | typename P, |
| 57 | typename Tuple, |
| 58 | size_t... Ns> |
| 59 | void DispatchToMethodImpl(ObjT* obj, |
| 60 | Method method, |
| 61 | P* parameter, |
tzik | d140291 | 2017-08-30 22:39:03 +0900 | [diff] [blame] | 62 | Tuple&& tuple, |
Jeremy Roman | 773e7f2 | 2017-08-17 00:55:20 +0900 | [diff] [blame] | 63 | std::index_sequence<Ns...>) { |
tzik | d140291 | 2017-08-30 22:39:03 +0900 | [diff] [blame] | 64 | (obj->*method)(parameter, std::get<Ns>(std::forward<Tuple>(tuple))...); |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 65 | } |
| 66 | |
| 67 | // The following function is for async IPCs which have a dispatcher with an |
| 68 | // extra parameter specified using IPC_BEGIN_MESSAGE_MAP_WITH_PARAM. |
tzik | d140291 | 2017-08-30 22:39:03 +0900 | [diff] [blame] | 69 | template <typename ObjT, typename P, typename... Args, typename Tuple> |
| 70 | std::enable_if_t<sizeof...(Args) == std::tuple_size<std::decay_t<Tuple>>::value> |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 71 | DispatchToMethod(ObjT* obj, |
| 72 | void (ObjT::*method)(P*, Args...), |
| 73 | P* parameter, |
tzik | d140291 | 2017-08-30 22:39:03 +0900 | [diff] [blame] | 74 | Tuple&& tuple) { |
| 75 | constexpr size_t size = std::tuple_size<std::decay_t<Tuple>>::value; |
| 76 | DispatchToMethodImpl(obj, method, parameter, std::forward<Tuple>(tuple), |
| 77 | std::make_index_sequence<size>()); |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 78 | } |
| 79 | |
| 80 | enum class MessageKind { |
| 81 | CONTROL, |
| 82 | ROUTED, |
| 83 | }; |
| 84 | |
| 85 | // Routing is a helper struct so MessageT's private common constructor has a |
| 86 | // different type signature than the public "int32_t routing_id" one. |
| 87 | struct Routing { |
| 88 | explicit Routing(int32_t id) : id(id) {} |
| 89 | int32_t id; |
| 90 | }; |
| 91 | |
| 92 | // We want to restrict MessageT's constructors so that a routing_id is always |
| 93 | // provided for ROUTED messages and never provided for CONTROL messages, so |
| 94 | // use the SFINAE technique from N4387's "Implementation Hint" section. |
| 95 | #if defined(COMPILER_MSVC) |
| 96 | // MSVC 2013 doesn't support default arguments for template member functions |
| 97 | // of templated classes, so there we have to rely on the DCHECKs instead. |
| 98 | // TODO(mdempsky): Reevaluate once MSVC 2015. |
| 99 | #define IPC_MESSAGET_SFINAE(x) |
| 100 | #else |
| 101 | #define IPC_MESSAGET_SFINAE(x) \ |
| 102 | template <bool X = (x), typename std::enable_if<X, bool>::type = false> |
| 103 | #endif |
| 104 | |
| 105 | // MessageT is the common template used for all user-defined message types. |
| 106 | // It's intended to be used via the macros defined in ipc_message_macros.h. |
| 107 | template <typename Meta, |
| 108 | typename InTuple = typename Meta::InTuple, |
| 109 | typename OutTuple = typename Meta::OutTuple> |
| 110 | class MessageT; |
| 111 | |
| 112 | // Asynchronous message partial specialization. |
| 113 | template <typename Meta, typename... Ins> |
tzik | a088e35 | 2016-03-08 14:47:44 +0900 | [diff] [blame] | 114 | class MessageT<Meta, std::tuple<Ins...>, void> : public Message { |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 115 | public: |
tzik | a088e35 | 2016-03-08 14:47:44 +0900 | [diff] [blame] | 116 | using Param = std::tuple<Ins...>; |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 117 | enum { ID = Meta::ID }; |
| 118 | |
| 119 | // TODO(mdempsky): Remove. Uses of MyMessage::Schema::Param can be replaced |
| 120 | // with just MyMessage::Param. |
| 121 | using Schema = MessageT; |
| 122 | |
| 123 | IPC_MESSAGET_SFINAE(Meta::kKind == MessageKind::CONTROL) |
| 124 | MessageT(const Ins&... ins) : MessageT(Routing(MSG_ROUTING_CONTROL), ins...) { |
| 125 | DCHECK(Meta::kKind == MessageKind::CONTROL) << Meta::kName; |
| 126 | } |
| 127 | |
| 128 | IPC_MESSAGET_SFINAE(Meta::kKind == MessageKind::ROUTED) |
| 129 | MessageT(int32_t routing_id, const Ins&... ins) |
| 130 | : MessageT(Routing(routing_id), ins...) { |
| 131 | DCHECK(Meta::kKind == MessageKind::ROUTED) << Meta::kName; |
| 132 | } |
| 133 | |
| 134 | static bool Read(const Message* msg, Param* p); |
| 135 | static void Log(std::string* name, const Message* msg, std::string* l); |
| 136 | |
| 137 | template <class T, class S, class P, class Method> |
| 138 | static bool Dispatch(const Message* msg, |
| 139 | T* obj, |
| 140 | S* sender, |
| 141 | P* parameter, |
| 142 | Method func) { |
ssid | 49c4822 | 2016-03-29 04:56:49 +0900 | [diff] [blame] | 143 | TRACE_EVENT0("ipc", Meta::kName); |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 144 | Param p; |
| 145 | if (Read(msg, &p)) { |
tzik | d140291 | 2017-08-30 22:39:03 +0900 | [diff] [blame] | 146 | DispatchToMethod(obj, func, parameter, std::move(p)); |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 147 | return true; |
| 148 | } |
| 149 | return false; |
| 150 | } |
| 151 | |
| 152 | private: |
| 153 | MessageT(Routing routing, const Ins&... ins); |
| 154 | }; |
| 155 | |
| 156 | // Synchronous message partial specialization. |
| 157 | template <typename Meta, typename... Ins, typename... Outs> |
tzik | a088e35 | 2016-03-08 14:47:44 +0900 | [diff] [blame] | 158 | class MessageT<Meta, std::tuple<Ins...>, std::tuple<Outs...>> |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 159 | : public SyncMessage { |
| 160 | public: |
tzik | a088e35 | 2016-03-08 14:47:44 +0900 | [diff] [blame] | 161 | using SendParam = std::tuple<Ins...>; |
| 162 | using ReplyParam = std::tuple<Outs...>; |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 163 | enum { ID = Meta::ID }; |
| 164 | |
| 165 | // TODO(mdempsky): Remove. Uses of MyMessage::Schema::{Send,Reply}Param can |
| 166 | // be replaced with just MyMessage::{Send,Reply}Param. |
| 167 | using Schema = MessageT; |
| 168 | |
| 169 | IPC_MESSAGET_SFINAE(Meta::kKind == MessageKind::CONTROL) |
| 170 | MessageT(const Ins&... ins, Outs*... outs) |
| 171 | : MessageT(Routing(MSG_ROUTING_CONTROL), ins..., outs...) { |
| 172 | DCHECK(Meta::kKind == MessageKind::CONTROL) << Meta::kName; |
| 173 | } |
| 174 | |
| 175 | IPC_MESSAGET_SFINAE(Meta::kKind == MessageKind::ROUTED) |
| 176 | MessageT(int32_t routing_id, const Ins&... ins, Outs*... outs) |
| 177 | : MessageT(Routing(routing_id), ins..., outs...) { |
| 178 | DCHECK(Meta::kKind == MessageKind::ROUTED) << Meta::kName; |
| 179 | } |
| 180 | |
| 181 | static bool ReadSendParam(const Message* msg, SendParam* p); |
| 182 | static bool ReadReplyParam(const Message* msg, ReplyParam* p); |
| 183 | static void WriteReplyParams(Message* reply, const Outs&... outs); |
| 184 | static void Log(std::string* name, const Message* msg, std::string* l); |
| 185 | |
| 186 | template <class T, class S, class P, class Method> |
| 187 | static bool Dispatch(const Message* msg, |
| 188 | T* obj, |
| 189 | S* sender, |
thestig | 286ee10 | 2016-11-17 14:56:32 +0900 | [diff] [blame] | 190 | P* /* parameter */, |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 191 | Method func) { |
ssid | 49c4822 | 2016-03-29 04:56:49 +0900 | [diff] [blame] | 192 | TRACE_EVENT0("ipc", Meta::kName); |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 193 | SendParam send_params; |
| 194 | bool ok = ReadSendParam(msg, &send_params); |
| 195 | Message* reply = SyncMessage::GenerateReply(msg); |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 196 | if (!ok) { |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 197 | NOTREACHED() << "Error deserializing message " << msg->type(); |
| 198 | reply->set_reply_error(); |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 199 | sender->Send(reply); |
| 200 | return false; |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 201 | } |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 202 | |
| 203 | ReplyParam reply_params; |
| 204 | base::DispatchToMethod(obj, func, std::move(send_params), &reply_params); |
| 205 | WriteParam(reply, reply_params); |
| 206 | LogReplyParamsToMessage(reply_params, msg); |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 207 | sender->Send(reply); |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 208 | return true; |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 209 | } |
| 210 | |
| 211 | template <class T, class P, class Method> |
| 212 | static bool DispatchDelayReply(const Message* msg, |
| 213 | T* obj, |
thestig | 286ee10 | 2016-11-17 14:56:32 +0900 | [diff] [blame] | 214 | P* /* parameter */, |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 215 | Method func) { |
ssid | 49c4822 | 2016-03-29 04:56:49 +0900 | [diff] [blame] | 216 | TRACE_EVENT0("ipc", Meta::kName); |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 217 | SendParam send_params; |
| 218 | bool ok = ReadSendParam(msg, &send_params); |
| 219 | Message* reply = SyncMessage::GenerateReply(msg); |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 220 | if (!ok) { |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 221 | NOTREACHED() << "Error deserializing message " << msg->type(); |
| 222 | reply->set_reply_error(); |
| 223 | obj->Send(reply); |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 224 | return false; |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 225 | } |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 226 | |
| 227 | std::tuple<Message&> t = std::tie(*reply); |
| 228 | ConnectMessageAndReply(msg, reply); |
| 229 | base::DispatchToMethod(obj, func, std::move(send_params), &t); |
| 230 | return true; |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 231 | } |
| 232 | |
thestig | 286ee10 | 2016-11-17 14:56:32 +0900 | [diff] [blame] | 233 | template <class T, class P, class Method> |
| 234 | static bool DispatchWithParamDelayReply(const Message* msg, |
| 235 | T* obj, |
| 236 | P* parameter, |
| 237 | Method func) { |
| 238 | TRACE_EVENT0("ipc", Meta::kName); |
| 239 | SendParam send_params; |
| 240 | bool ok = ReadSendParam(msg, &send_params); |
| 241 | Message* reply = SyncMessage::GenerateReply(msg); |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 242 | if (!ok) { |
thestig | 286ee10 | 2016-11-17 14:56:32 +0900 | [diff] [blame] | 243 | NOTREACHED() << "Error deserializing message " << msg->type(); |
| 244 | reply->set_reply_error(); |
| 245 | obj->Send(reply); |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 246 | return false; |
thestig | 286ee10 | 2016-11-17 14:56:32 +0900 | [diff] [blame] | 247 | } |
tzik | c8447f5 | 2017-08-31 20:49:59 +0900 | [diff] [blame] | 248 | |
| 249 | std::tuple<Message&> t = std::tie(*reply); |
| 250 | ConnectMessageAndReply(msg, reply); |
| 251 | std::tuple<P*> parameter_tuple(parameter); |
| 252 | base::DispatchToMethod( |
| 253 | obj, func, |
| 254 | std::tuple_cat(std::move(parameter_tuple), TupleForward(send_params)), |
| 255 | &t); |
| 256 | return true; |
thestig | 286ee10 | 2016-11-17 14:56:32 +0900 | [diff] [blame] | 257 | } |
| 258 | |
mdempsky | fba51c1 | 2016-02-09 14:41:47 +0900 | [diff] [blame] | 259 | private: |
| 260 | MessageT(Routing routing, const Ins&... ins, Outs*... outs); |
| 261 | }; |
| 262 | |
| 263 | } // namespace IPC |
| 264 | |
| 265 | #if defined(IPC_MESSAGE_IMPL) |
| 266 | #include "ipc/ipc_message_templates_impl.h" |
| 267 | #endif |
| 268 | |
| 269 | #endif // IPC_IPC_MESSAGE_TEMPLATES_H_ |