Remove base::Tuple

content/renderer/media/renderer_webmediaplayer_delegate_browsertest.cc

 // Copyright 2016 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 <tuple>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
-#include "base/tuple.h"
 #include "content/common/media/media_player_delegate_messages.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/test/render_view_test.h"
 #include "content/renderer/media/renderer_webmediaplayer_delegate.h"
 #include "content/renderer/render_process.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
@@ skipping 51 matching lines @@
   {
     const bool kHasVideo = true, kHasAudio = false, kIsRemote = false;
     const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(5);
     delegate_manager_->DidPlay(delegate_id, kHasVideo, kHasAudio, kIsRemote,
                                kDuration);
 
     const IPC::Message* msg = test_sink().GetUniqueMessageMatching(
         MediaPlayerDelegateHostMsg_OnMediaPlaying::ID);
     ASSERT_TRUE(msg);
 
-    base::Tuple<int, bool, bool, bool, base::TimeDelta> result;
+    std::tuple<int, bool, bool, bool, base::TimeDelta> result;
     ASSERT_TRUE(MediaPlayerDelegateHostMsg_OnMediaPlaying::Read(msg, &result));
-    EXPECT_EQ(delegate_id, base::get<0>(result));
-    EXPECT_EQ(kHasVideo, base::get<1>(result));
-    EXPECT_EQ(kHasAudio, base::get<2>(result));
-    EXPECT_EQ(kIsRemote, base::get<3>(result));
-    EXPECT_EQ(kDuration, base::get<4>(result));
+    EXPECT_EQ(delegate_id, std::get<0>(result));
+    EXPECT_EQ(kHasVideo, std::get<1>(result));
+    EXPECT_EQ(kHasAudio, std::get<2>(result));
+    EXPECT_EQ(kIsRemote, std::get<3>(result));
+    EXPECT_EQ(kDuration, std::get<4>(result));
   }
 
   // Verify the paused message.
   {
     test_sink().ClearMessages();
     const bool kReachedEndOfStream = true;
     delegate_manager_->DidPause(delegate_id, kReachedEndOfStream);
 
     const IPC::Message* msg = test_sink().GetUniqueMessageMatching(
         MediaPlayerDelegateHostMsg_OnMediaPaused::ID);
     ASSERT_TRUE(msg);
 
-    base::Tuple<int, bool> result;
+    std::tuple<int, bool> result;
     ASSERT_TRUE(MediaPlayerDelegateHostMsg_OnMediaPaused::Read(msg, &result));
-    EXPECT_EQ(delegate_id, base::get<0>(result));
-    EXPECT_EQ(kReachedEndOfStream, base::get<1>(result));
+    EXPECT_EQ(delegate_id, std::get<0>(result));
+    EXPECT_EQ(kReachedEndOfStream, std::get<1>(result));
   }
 
   // Verify the destruction message.
   {
     test_sink().ClearMessages();
     delegate_manager_->PlayerGone(delegate_id);
     const IPC::Message* msg = test_sink().GetUniqueMessageMatching(
         MediaPlayerDelegateHostMsg_OnMediaDestroyed::ID);
     ASSERT_TRUE(msg);
 
-    base::Tuple<int> result;
+    std::tuple<int> result;
     ASSERT_TRUE(
         MediaPlayerDelegateHostMsg_OnMediaDestroyed::Read(msg, &result));
-    EXPECT_EQ(delegate_id, base::get<0>(result));
+    EXPECT_EQ(delegate_id, std::get<0>(result));
   }
 
   delegate_manager_->RemoveObserver(delegate_id);
 }
 
 TEST_F(RendererWebMediaPlayerDelegateTest, DeliversObserverNotifications) {
   testing::StrictMock<MockWebMediaPlayerDelegateObserver> observer;
   const int delegate_id = delegate_manager_->AddObserver(&observer);
 
   EXPECT_CALL(observer, OnHidden());
@@ skipping 129 matching lines @@
   tick_clock.Advance(kIdleTimeout + base::TimeDelta::FromMicroseconds(1));
   run_loop.Run();
 
   // Even though the player did not call PlayerGone() it should be removed from
   // future idle cleanup polls.
   EXPECT_FALSE(delegate_manager_->IsIdleCleanupTimerRunningForTesting());
   delegate_manager_->RemoveObserver(delegate_id_1);
 }
 
 }  // namespace media