Remove base::Tuple

content/browser/shared_worker/shared_worker_service_impl_unittest.cc

 // Copyright 2014 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 "content/browser/shared_worker/shared_worker_service_impl.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <set>
+#include <tuple>
 #include <vector>
 
 #include "base/atomic_sequence_num.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/shared_worker/shared_worker_message_filter.h"
@@ skipping 303 matching lines @@
 };
 
 void CheckWorkerProcessMsgCreateWorker(
     MockRendererProcessHost* renderer_host,
     const std::string& expected_url,
     const std::string& expected_name,
     blink::WebContentSecurityPolicyType expected_security_policy_type,
     int* route_id) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type());
-  base::Tuple<WorkerProcessMsg_CreateWorker_Params> param;
+  std::tuple<WorkerProcessMsg_CreateWorker_Params> param;
   EXPECT_TRUE(WorkerProcessMsg_CreateWorker::Read(msg.get(), &param));
-  EXPECT_EQ(GURL(expected_url), base::get<0>(param).url);
-  EXPECT_EQ(base::ASCIIToUTF16(expected_name), base::get<0>(param).name);
+  EXPECT_EQ(GURL(expected_url), std::get<0>(param).url);
+  EXPECT_EQ(base::ASCIIToUTF16(expected_name), std::get<0>(param).name);
   EXPECT_EQ(expected_security_policy_type,
-            base::get<0>(param).security_policy_type);
-  *route_id = base::get<0>(param).route_id;
+            std::get<0>(param).security_policy_type);
+  *route_id = std::get<0>(param).route_id;
 }
 
 void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host,
                                MockSharedWorkerConnector* connector) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(ViewMsg_WorkerCreated::ID, msg->type());
   EXPECT_EQ(connector->route_id(), msg->routing_id());
 }
 
 void CheckMessagePortMsgMessagesQueued(MockRendererProcessHost* renderer_host,
                                        MockSharedWorkerConnector* connector) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(MessagePortMsg_MessagesQueued::ID, msg->type());
   EXPECT_EQ(connector->temporary_remote_port_route_id(), msg->routing_id());
 }
 
 void CheckWorkerMsgConnect(MockRendererProcessHost* renderer_host,
                            int expected_msg_route_id,
                            int expected_sent_message_port_id,
                            int* routing_id) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(WorkerMsg_Connect::ID, msg->type());
   EXPECT_EQ(expected_msg_route_id, msg->routing_id());
   WorkerMsg_Connect::Param params;
   EXPECT_TRUE(WorkerMsg_Connect::Read(msg.get(), &params));
-  int port_id = base::get<0>(params);
-  *routing_id = base::get<1>(params);
+  int port_id = std::get<0>(params);
+  *routing_id = std::get<1>(params);
   EXPECT_EQ(expected_sent_message_port_id, port_id);
 }
 
 void CheckMessagePortMsgMessage(MockRendererProcessHost* renderer_host,
                                 int expected_msg_route_id,
                                 std::string expected_data) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(MessagePortMsg_Message::ID, msg->type());
   EXPECT_EQ(expected_msg_route_id, msg->routing_id());
   MessagePortMsg_Message::Param params;
   EXPECT_TRUE(MessagePortMsg_Message::Read(msg.get(), &params));
-  base::string16 data = base::get<0>(params);
+  base::string16 data = std::get<0>(params);
   EXPECT_EQ(base::ASCIIToUTF16(expected_data), data);
 }
 
 void CheckViewMsgWorkerConnected(MockRendererProcessHost* renderer_host,
                                  MockSharedWorkerConnector* connector) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(ViewMsg_WorkerConnected::ID, msg->type());
   EXPECT_EQ(connector->route_id(), msg->routing_id());
 }
 
@@ skipping 526 matching lines @@
                      kDocumentIDs[2],
                      kRenderFrameRouteIDs[2]);
   EXPECT_NE(MSG_ROUTING_NONE, connector2->route_id());
   EXPECT_EQ(0U, renderer_host2->QueuedMessageCount());
   RunAllPendingInMessageLoop();
   EXPECT_EQ(1U, renderer_host2->QueuedMessageCount());
   CheckViewMsgWorkerCreated(renderer_host2.get(), connector2.get());
 }
 
 }  // namespace content