Replace base::Tuple in //ipc with std::tuple

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>
 
 #include "base/logging.h"
 #include "base/tuple.h"

[Tom Sepez, 2016/03/07 19:05:02]

ditto and ditto

[tzik, 2016/03/08 03:32:59]

Added <tuple>.

Let me leave "base/tuple.h" here. We still need it for base::DispatchToMethod().

 #include "build/build_config.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_utils.h"
 
 namespace IPC {
 
 // This function is for all the async IPCs that don't pass an extra parameter
 // using IPC_BEGIN_MESSAGE_MAP_WITH_PARAM.
 template <typename ObjT, typename Method, typename P, typename Tuple>
 void DispatchToMethod(ObjT* obj, Method method, P*, const Tuple& tuple) {
   base::DispatchToMethod(obj, method, tuple);
 }
 
 template <typename ObjT,
           typename Method,
           typename P,
           typename Tuple,
           size_t... Ns>
 void DispatchToMethodImpl(ObjT* obj,
                           Method method,
                           P* parameter,
                           const Tuple& tuple,
                           base::IndexSequence<Ns...>) {
   // TODO(mdempsky): Apply UnwrapTraits like base::DispatchToMethod?
-  (obj->*method)(parameter, base::get<Ns>(tuple)...);
+  (obj->*method)(parameter, std::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,
                  void (ObjT::*method)(P*, Args...),
                  P* parameter,
-                 const base::Tuple<Ts...>& tuple) {
+                 const std::tuple<Ts...>& tuple) {
   DispatchToMethodImpl(obj, method, parameter, tuple,
                        base::MakeIndexSequence<sizeof...(Ts)>());
 }
 
 enum class MessageKind {
   CONTROL,
   ROUTED,
 };
 
 // Routing is a helper struct so MessageT's private common constructor has a
@@ skipping 18 matching lines @@
 
 // MessageT is the common template used for all user-defined message types.
 // It's intended to be used via the macros defined in ipc_message_macros.h.
 template <typename Meta,
           typename InTuple = typename Meta::InTuple,
           typename OutTuple = typename Meta::OutTuple>
 class MessageT;
 
 // Asynchronous message partial specialization.
 template <typename Meta, typename... Ins>
-class MessageT<Meta, base::Tuple<Ins...>, void> : public Message {
+class MessageT<Meta, std::tuple<Ins...>, void> : public Message {
  public:
-  using Param = base::Tuple<Ins...>;
+  using Param = std::tuple<Ins...>;
   enum { ID = Meta::ID };
 
   // TODO(mdempsky): Remove.  Uses of MyMessage::Schema::Param can be replaced
   // with just MyMessage::Param.
   using Schema = MessageT;
 
   IPC_MESSAGET_SFINAE(Meta::kKind == MessageKind::CONTROL)
   MessageT(const Ins&... ins) : MessageT(Routing(MSG_ROUTING_CONTROL), ins...) {
     DCHECK(Meta::kKind == MessageKind::CONTROL) << Meta::kName;
   }
@@ skipping 20 matching lines @@
     }
     return false;
   }
 
  private:
   MessageT(Routing routing, const Ins&... ins);
 };
 
 // Synchronous message partial specialization.
 template <typename Meta, typename... Ins, typename... Outs>
-class MessageT<Meta, base::Tuple<Ins...>, base::Tuple<Outs...>>
+class MessageT<Meta, std::tuple<Ins...>, std::tuple<Outs...>>
     : public SyncMessage {
  public:
-  using SendParam = base::Tuple<Ins...>;
-  using ReplyParam = base::Tuple<Outs...>;
+  using SendParam = std::tuple<Ins...>;
+  using ReplyParam = std::tuple<Outs...>;
   enum { ID = Meta::ID };
 
   // TODO(mdempsky): Remove.  Uses of MyMessage::Schema::{Send,Reply}Param can
   // be replaced with just MyMessage::{Send,Reply}Param.
   using Schema = MessageT;
 
   IPC_MESSAGET_SFINAE(Meta::kKind == MessageKind::CONTROL)
   MessageT(const Ins&... ins, Outs*... outs)
       : MessageT(Routing(MSG_ROUTING_CONTROL), ins..., outs...) {
     DCHECK(Meta::kKind == MessageKind::CONTROL) << Meta::kName;
@@ skipping 34 matching lines @@
 
   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);
+      std::tuple<Message&> t = std::tie(*reply);
       ConnectMessageAndReply(msg, reply);
       base::DispatchToMethod(obj, func, 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_