Remove base::Tuple

content/browser/frame_host/render_frame_host_manager_unittest.cc

 // Copyright 2013 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/frame_host/render_frame_host_manager.h"
 
 #include <stdint.h>
 
+#include <tuple>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ skipping 46 matching lines @@
 // page focus message with the provided focus and routing ID values.
 void VerifyPageFocusMessage(MockRenderProcessHost* rph,
                             bool expected_focus,
                             int expected_routing_id) {
   const IPC::Message* message =
       rph->sink().GetUniqueMessageMatching(InputMsg_SetFocus::ID);
   EXPECT_TRUE(message);
   EXPECT_EQ(expected_routing_id, message->routing_id());
   InputMsg_SetFocus::Param params;
   EXPECT_TRUE(InputMsg_SetFocus::Read(message, &params));
-  EXPECT_EQ(expected_focus, base::get<0>(params));
+  EXPECT_EQ(expected_focus, std::get<0>(params));
 }
 
 // Helper function for strict mixed content checking tests.
 void CheckMixedContentIPC(TestRenderFrameHost* rfh,
                           bool expected_param,
                           int expected_routing_id) {
   const IPC::Message* message =
       rfh->GetProcess()->sink().GetUniqueMessageMatching(
           FrameMsg_EnforceStrictMixedContentChecking::ID);
   ASSERT_TRUE(message);
   EXPECT_EQ(expected_routing_id, message->routing_id());
   FrameMsg_EnforceStrictMixedContentChecking::Param params;
   EXPECT_TRUE(
       FrameMsg_EnforceStrictMixedContentChecking::Read(message, &params));
-  EXPECT_EQ(expected_param, base::get<0>(params));
+  EXPECT_EQ(expected_param, std::get<0>(params));
 }
 
 class RenderFrameHostManagerTestWebUIControllerFactory
     : public WebUIControllerFactory {
  public:
   RenderFrameHostManagerTestWebUIControllerFactory()
       : should_create_webui_(false), type_(1) {
     CHECK_NE(reinterpret_cast<WebUI::TypeID>(type_), WebUI::kNoWebUI);
   }
   ~RenderFrameHostManagerTestWebUIControllerFactory() override {}
@@ skipping 2123 matching lines @@
 
   // Setting tab2_proxy's opener required an extra IPC message to be set, since
   // the opener's routing ID wasn't available when tab2_proxy was created.
   // Verify that this IPC was sent and that it passed correct routing ID.
   const IPC::Message* message =
       rfh2->GetProcess()->sink().GetUniqueMessageMatching(
           FrameMsg_UpdateOpener::ID);
   EXPECT_TRUE(message);
   FrameMsg_UpdateOpener::Param params;
   EXPECT_TRUE(FrameMsg_UpdateOpener::Read(message, &params));
-  EXPECT_EQ(tab2_opener_routing_id, base::get<0>(params));
+  EXPECT_EQ(tab2_opener_routing_id, std::get<0>(params));
 }
 
 // Test that opener proxies are created properly when the opener points
 // to itself.
 TEST_F(RenderFrameHostManagerTest, CreateOpenerProxiesWhenOpenerPointsToSelf) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
 
   // Navigate to an initial URL.
   contents()->NavigateAndCommit(kUrl1);
@@ skipping 26 matching lines @@
 
   // Setting the opener in opener_proxy required an extra IPC message, since
   // the opener's routing ID wasn't available when opener_proxy was created.
   // Verify that this IPC was sent and that it passed correct routing ID.
   const IPC::Message* message =
       rfh2->GetProcess()->sink().GetUniqueMessageMatching(
           FrameMsg_UpdateOpener::ID);
   EXPECT_TRUE(message);
   FrameMsg_UpdateOpener::Param params;
   EXPECT_TRUE(FrameMsg_UpdateOpener::Read(message, &params));
-  EXPECT_EQ(opener_routing_id, base::get<0>(params));
+  EXPECT_EQ(opener_routing_id, std::get<0>(params));
 }
 
 // Build the following frame opener graph and see that it can be properly
 // traversed when creating opener proxies:
 //
 //     +-> root4 <--+   root3 <---- root2    +--- root1
 //     |     /      |     ^         /  \     |    /  \     .
 //     |    42      +-----|------- 22  23 <--+   12  13
 //     |     +------------+            |             | ^
 //     +-------------------------------+             +-+
@@ skipping 803 matching lines @@
   commit_params.should_enforce_strict_mixed_content_checking = false;
   child_host->SendNavigateWithParams(&commit_params);
   EXPECT_NO_FATAL_FAILURE(CheckMixedContentIPC(
       main_test_rfh(), false, proxy_to_parent->GetRoutingID()));
   EXPECT_FALSE(root->child_at(0)
                    ->current_replication_state()
                    .should_enforce_strict_mixed_content_checking);
 }
 
 }  // namespace content