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

ppapi/proxy/resource_message_test_sink.cc

 // 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.
 
 #include "ppapi/proxy/resource_message_test_sink.h"
 
 #include <stddef.h>
 
+#include <tuple>
+
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/resource_message_params.h"
 #include "ppapi/proxy/serialized_handle.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 // Backend for GetAllResource[Calls|Replies]Matching.
 template <class WrapperMessage, class Params>
 std::vector<std::pair<Params, IPC::Message>> GetAllResourceMessagesMatching(
     const ResourceMessageTestSink& sink,
     uint32_t id) {
   std::vector<std::pair<Params, IPC::Message> > result;
   for (size_t i = 0; i < sink.message_count(); i++) {
     const IPC::Message* msg = sink.GetMessageAt(i);
     if (msg->type() == WrapperMessage::ID) {
       typename WrapperMessage::Param params;
       WrapperMessage::Read(msg, &params);
-      Params cur_params = base::get<0>(params);
-      IPC::Message cur_msg = base::get<1>(params);
+      Params cur_params = std::get<0>(params);
+      IPC::Message cur_msg = std::get<1>(params);
       if (cur_msg.type() == id) {
         result.push_back(std::make_pair(cur_params, cur_msg));
       }
     }
   }
   return result;
 }
 
 }  // namespace
 
@@ skipping 83 matching lines @@
 ResourceSyncCallHandler::~ResourceSyncCallHandler() {
 }
 
 bool ResourceSyncCallHandler::OnMessageReceived(const IPC::Message& msg) {
   if (msg.type() != PpapiHostMsg_ResourceSyncCall::ID)
     return false;
   PpapiHostMsg_ResourceSyncCall::Schema::SendParam send_params;
   bool success = PpapiHostMsg_ResourceSyncCall::ReadSendParam(
       &msg, &send_params);
   DCHECK(success);
-  ResourceMessageCallParams call_params = base::get<0>(send_params);
-  IPC::Message call_msg = base::get<1>(send_params);
+  ResourceMessageCallParams call_params = std::get<0>(send_params);
+  IPC::Message call_msg = std::get<1>(send_params);
   if (call_msg.type() != incoming_type_)
     return false;
   IPC::Message* wrapper_reply_msg = IPC::SyncMessage::GenerateReply(&msg);
   ResourceMessageReplyParams reply_params(call_params.pp_resource(),
                                           call_params.sequence());
   reply_params.set_result(result_);
   if (serialized_handle_)
     reply_params.AppendHandle(*serialized_handle_);
   PpapiHostMsg_ResourceSyncCall::WriteReplyParams(
       wrapper_reply_msg, reply_params, reply_msg_);
   test_sink_->SetSyncReplyMessage(wrapper_reply_msg);
 
   // Stash a copy of the message for inspection later.
   last_handled_msg_ = call_msg;
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi