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

ipc/attachment_broker_privileged_win_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 <windows.h>
 
+#include <tuple>
+
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/shared_memory_handle.h"
 #include "base/win/scoped_handle.h"
 #include "ipc/attachment_broker_privileged_win.h"
 #include "ipc/attachment_broker_unprivileged_win.h"
 #include "ipc/handle_attachment_win.h"
@@ skipping 50 matching lines @@
     return ScopedHandle(nullptr);
   }
 
   TestHandleWinMsg::Schema::Param p;
   bool success = TestHandleWinMsg::Read(&message, &p);
   if (!success) {
     LOG(INFO) << "Failed to deserialize message.";
     return ScopedHandle(nullptr);
   }
 
-  IPC::HandleWin handle_win = base::get<1>(p);
+  IPC::HandleWin handle_win = std::get<1>(p);
   return ScopedHandle(handle_win.get_handle());
 }
 
 // Returns a mapped, shared memory region based on the handle in |message|.
 scoped_ptr<base::SharedMemory> GetSharedMemoryFromSharedMemoryHandleMsg1(
     const IPC::Message& message,
     size_t size) {
   // Expect a message with a brokered attachment.
   if (!message.HasBrokerableAttachments()) {
     LOG(INFO) << "Message missing brokerable attachment.";
     return nullptr;
   }
 
   TestSharedMemoryHandleMsg1::Schema::Param p;
   bool success = TestSharedMemoryHandleMsg1::Read(&message, &p);
   if (!success) {
     LOG(INFO) << "Failed to deserialize message.";
     return nullptr;
   }
 
-  base::SharedMemoryHandle handle = base::get<0>(p);
+  base::SharedMemoryHandle handle = std::get<0>(p);
   scoped_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(handle, false));
 
   shared_memory->Map(size);
   return shared_memory;
 }
 
 // |message| must be deserializable as a TestTwoHandleWinMsg. Returns the
 // HANDLE, or nullptr if deserialization failed.
 bool GetHandleFromTestTwoHandleWinMsg(const IPC::Message& message,
                                       HANDLE* h1,
                                       HANDLE* h2) {
   // Expect a message with a brokered attachment.
   if (!message.HasBrokerableAttachments()) {
     LOG(INFO) << "Message missing brokerable attachment.";
     return false;
   }
 
   TestTwoHandleWinMsg::Schema::Param p;
   bool success = TestTwoHandleWinMsg::Read(&message, &p);
   if (!success) {
     LOG(INFO) << "Failed to deserialize message.";
     return false;
   }
 
-  IPC::HandleWin handle_win = base::get<0>(p);
+  IPC::HandleWin handle_win = std::get<0>(p);
   *h1 = handle_win.get_handle();
-  handle_win = base::get<1>(p);
+  handle_win = std::get<1>(p);
   *h2 = handle_win.get_handle();
   return true;
 }
 
 // |message| must be deserializable as a TestHandleWinMsg. Returns true if the
 // attached file HANDLE has contents |kDataBuffer|.
 bool CheckContentsOfTestMessage(const IPC::Message& message) {
   ScopedHandle h(GetHandleFromTestHandleWinMsg(message));
   if (h.Get() == nullptr) {
     LOG(INFO) << "Failed to get handle from TestHandleWinMsg.";
@@ skipping 504 matching lines @@
       memcmp(shared_memory->memory(), kDataBuffer, strlen(kDataBuffer)) == 0;
   SendControlMessage(sender, success);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandle) {
   return CommonPrivilegedProcessMain(&SendSharedMemoryHandleCallback,
                                      "SendSharedMemoryHandle");
 }
 
 }  // namespace