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

ppapi/proxy/dispatch_reply_message.h

 // Copyright (c) 2012 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.
 
 // This file provides infrastructure for dispatching messasges from host
 // resource, inlcuding reply messages or unsolicited replies. Normal IPC Reply
 // handlers can't take extra parameters. We want to take a
 // ResourceMessageReplyParams as a parameter.
 
 #ifndef PPAPI_PROXY_DISPATCH_REPLY_MESSAGE_H_
 #define PPAPI_PROXY_DISPATCH_REPLY_MESSAGE_H_
 
+#include <tuple>
+
 #include "base/callback.h"
 #include "ipc/ipc_message_macros.h"
 #include "ppapi/c/pp_errors.h"
 
 namespace ppapi {
 namespace proxy {
 
 class ResourceMessageReplyParams;
 
 template <class ObjT, class Method>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const base::Tuple<>& arg) {
+                                  const std::tuple<>& arg) {
   (obj->*method)(params);
 }
 
 template <class ObjT, class Method, class A>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const base::Tuple<A>& arg) {
-  (obj->*method)(params, base::get<0>(arg));
+                                  const std::tuple<A>& arg) {
+  (obj->*method)(params, std::get<0>(arg));
 }
 
 template<class ObjT, class Method, class A, class B>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const base::Tuple<A, B>& arg) {
-  (obj->*method)(params, base::get<0>(arg), base::get<1>(arg));
+                                  const std::tuple<A, B>& arg) {
+  (obj->*method)(params, std::get<0>(arg), std::get<1>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const base::Tuple<A, B, C>& arg) {
-  (obj->*method)(params, base::get<0>(arg), base::get<1>(arg),
-                 base::get<2>(arg));
+                                  const std::tuple<A, B, C>& arg) {
+  (obj->*method)(params, std::get<0>(arg), std::get<1>(arg),
+                 std::get<2>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C, class D>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const base::Tuple<A, B, C, D>& arg) {
-  (obj->*method)(params, base::get<0>(arg), base::get<1>(arg),
-                 base::get<2>(arg), base::get<3>(arg));
+                                  const std::tuple<A, B, C, D>& arg) {
+  (obj->*method)(params, std::get<0>(arg), std::get<1>(arg),
+                 std::get<2>(arg), std::get<3>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C, class D, class E>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const base::Tuple<A, B, C, D, E>& arg) {
-  (obj->*method)(params, base::get<0>(arg), base::get<1>(arg),
-                 base::get<2>(arg), base::get<3>(arg), base::get<4>(arg));
+                                  const std::tuple<A, B, C, D, E>& arg) {
+  (obj->*method)(params, std::get<0>(arg), std::get<1>(arg),
+                 std::get<2>(arg), std::get<3>(arg), std::get<4>(arg));
 }
 
 // Used to dispatch resource replies. In most cases, you should not call this
 // function to dispatch a resource reply manually, but instead use
 // |PluginResource::CallBrowser|/|PluginResource::CallRenderer| with a
 // |base::Callback| which will be called when a reply message is received
 // (see plugin_resource.h).
 //
 // This function will call your callback with the nested reply message's
 // parameters on success. On failure, your callback will be called with each
@@ skipping 96 matching lines @@
     break;
 
 #define PPAPI_END_MESSAGE_MAP() \
   } \
 }
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_DISPATCH_REPLY_MESSAGE_H_