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

ipc/attachment_broker_mac_unittest.cc

 // 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.
 
 #include "build/build_config.h"
 
 #include <fcntl.h>
 #include <mach/mach_vm.h>
 #include <stddef.h>
 #include <sys/mman.h>
 
 #include "base/command_line.h"

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

#inlcude <tuple>

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

Done.

 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/mach_logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/spin_wait.h"
 #include "base/time/time.h"
@@ skipping 81 matching lines @@
     LOG(ERROR) << "Message missing brokerable attachment.";
     return base::SharedMemoryHandle();
   }
 
   TestSharedMemoryHandleMsg1::Schema::Param p;
   if (!TestSharedMemoryHandleMsg1::Read(&message, &p)) {
     LOG(ERROR) << "Failed to deserialize message.";
     return base::SharedMemoryHandle();
   }
 
-  return base::get<1>(p);
+  return std::get<1>(p);
 }
 
 // |message| must be deserializable as a TestSharedMemoryHandleMsg2. Returns
 // whether deserialization was successful. |handle1| and |handle2| are output
 // variables populated on success.
 bool GetSharedMemoryHandlesFromMsg2(const IPC::Message& message,
                                     base::SharedMemoryHandle* handle1,
                                     base::SharedMemoryHandle* handle2) {
   // Expect a message with a brokered attachment.
   if (!message.HasBrokerableAttachments()) {
     LOG(ERROR) << "Message missing brokerable attachment.";
     return false;
   }
 
   TestSharedMemoryHandleMsg2::Schema::Param p;
   if (!TestSharedMemoryHandleMsg2::Read(&message, &p)) {
     LOG(ERROR) << "Failed to deserialize message.";
     return false;
   }
 
-  *handle1 = base::get<0>(p);
-  *handle2 = base::get<1>(p);
+  *handle1 = std::get<0>(p);
+  *handle2 = std::get<1>(p);
   return true;
 }
 
 // Returns |nullptr| on error.
 scoped_ptr<base::SharedMemory> MapSharedMemoryHandle(
     const base::SharedMemoryHandle& shm,
     bool read_only) {
   if (!shm.IsValid()) {
     LOG(ERROR) << "Invalid SharedMemoryHandle";
     return nullptr;
@@ skipping 714 matching lines @@
 void SendPosixFDAndMachPortCallback(IPC::Sender* sender,
                                     const IPC::Message& message,
                                     ChildProcessGlobals* globals) {
   TestSharedMemoryHandleMsg3::Schema::Param p;
   if (!TestSharedMemoryHandleMsg3::Read(&message, &p)) {
     LOG(ERROR) << "Failed to deserialize message.";
     SendControlMessage(sender, false);
     return;
   }
 
-  base::SharedMemoryHandle handle1 = base::get<1>(p);
-  base::SharedMemoryHandle handle2 = base::get<3>(p);
+  base::SharedMemoryHandle handle1 = std::get<1>(p);
+  base::SharedMemoryHandle handle2 = std::get<3>(p);
   bool success1 = CheckContentsOfSharedMemoryHandle(handle1, kDataBuffer1) &&
                   CheckContentsOfSharedMemoryHandle(handle2, kDataBuffer2);
   if (!success1)
     LOG(ERROR) << "SharedMemoryHandles have wrong contents.";
 
   bool success2 =
-      CheckContentsOfFileDescriptor(base::get<0>(p), kDataBuffer3) &&
-      CheckContentsOfFileDescriptor(base::get<2>(p), kDataBuffer4);
+      CheckContentsOfFileDescriptor(std::get<0>(p), kDataBuffer3) &&
+      CheckContentsOfFileDescriptor(std::get<2>(p), kDataBuffer4);
   if (!success2)
     LOG(ERROR) << "FileDescriptors have wrong contents.";
 
   SendControlMessage(sender, success1 && success2);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendPosixFDAndMachPort) {
   return CommonPrivilegedProcessMain(&SendPosixFDAndMachPortCallback,
                                      "SendPosixFDAndMachPort");
 }
@@ skipping 435 matching lines @@
     SendControlMessage(sender, success);
   }
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(MemoryUsageManyMessages) {
   return CommonPrivilegedProcessMain(&MemoryUsageManyMessagesCallback,
                                      "MemoryUsageManyMessages");
 }
 
 }  // namespace