Remove base::Tuple

media/gpu/video_decode_accelerator_unittest.cc

 // Copyright (c) 2012 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
 //   to be written sequentially and wait for the decode client to see certain
 //   state transitions.
 // - GLRenderingVDAClient is a VideoDecodeAccelerator::Client implementation
 // - Finally actual TEST cases are at the bottom of this file, using the above
 //   infrastructure.
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <algorithm>
 #include <deque>
 #include <map>
 #include <memory>
+#include <tuple>
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
@@ skipping 43 matching lines @@
 #include "ui/ozone/public/ozone_gpu_test_helper.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #endif  // defined(USE_OZONE)
 
 using media::VideoDecodeAccelerator;
 
 namespace media {
 namespace {
 
-using base::MakeTuple;
-
 // Values optionally filled in from flags; see main() below.
 // The syntax of multiple test videos is:
 //  test-video1;test-video2;test-video3
 // where only the first video is required and other optional videos would be
 // decoded by concurrent decoders.
 // The syntax of each test-video is:
 //  filename:width:height:numframes:numfragments:minFPSwithRender:minFPSnoRender
 // where only the first field is required.  Value details:
 // - |filename| must be an h264 Annex B (NAL) stream or an IVF VP8/9 stream.
 // - |width| and |height| are in pixels.
@@ skipping 1133 matching lines @@
 //   instantiated.
 // - Number of concurrent in-flight Decode() calls per decoder.
 // - Number of play-throughs.
 // - reset_after_frame_num: see GLRenderingVDAClient ctor.
 // - delete_decoder_phase: see GLRenderingVDAClient ctor.
 // - whether to test slow rendering by delaying ReusePictureBuffer().
 // - whether the video frames are rendered as thumbnails.
 class VideoDecodeAcceleratorParamTest
     : public VideoDecodeAcceleratorTest,
       public ::testing::WithParamInterface<
-          base::Tuple<int, int, int, ResetPoint, ClientState, bool, bool>> {};
+          std::tuple<int, int, int, ResetPoint, ClientState, bool, bool>> {};
 
 // Wait for |note| to report a state and if it's not |expected_state| then
 // assert |client| has deleted its decoder.
 static void AssertWaitForStateOrDeleted(
     ClientStateNotification<ClientState>* note,
     GLRenderingVDAClient* client,
     ClientState expected_state) {
   ClientState state = note->Wait();
   if (state == expected_state)
     return;
   ASSERT_TRUE(client->decoder_deleted())
       << "Decoder not deleted but Wait() returned " << state
       << ", instead of " << expected_state;
 }
 
 // We assert a minimal number of concurrent decoders we expect to succeed.
 // Different platforms can support more concurrent decoders, so we don't assert
 // failure above this.
 enum { kMinSupportedNumConcurrentDecoders = 3 };
 
 // Test the most straightforward case possible: data is decoded from a single
 // chunk and rendered to the screen.
 TEST_P(VideoDecodeAcceleratorParamTest, TestSimpleDecode) {
-  size_t num_concurrent_decoders = base::get<0>(GetParam());
-  const size_t num_in_flight_decodes = base::get<1>(GetParam());
-  int num_play_throughs = base::get<2>(GetParam());
-  const int reset_point = base::get<3>(GetParam());
-  const int delete_decoder_state = base::get<4>(GetParam());
-  bool test_reuse_delay = base::get<5>(GetParam());
-  const bool render_as_thumbnails = base::get<6>(GetParam());
+  size_t num_concurrent_decoders = std::get<0>(GetParam());
+  const size_t num_in_flight_decodes = std::get<1>(GetParam());
+  int num_play_throughs = std::get<2>(GetParam());
+  const int reset_point = std::get<3>(GetParam());
+  const int delete_decoder_state = std::get<4>(GetParam());
+  bool test_reuse_delay = std::get<5>(GetParam());
+  const bool render_as_thumbnails = std::get<6>(GetParam());
 
   if (test_video_files_.size() > 1)
     num_concurrent_decoders = test_video_files_.size();
 
   if (g_num_play_throughs > 0)
     num_play_throughs = g_num_play_throughs;
 
   UpdateTestVideoFileParams(num_concurrent_decoders, reset_point,
                             &test_video_files_);
 
@@ skipping 194 matching lines @@
                      std::vector<ClientStateNotification<ClientState>*>>,
                  &notes));
   WaitUntilIdle();
 };
 
 // Test that replay after EOS works fine.
 INSTANTIATE_TEST_CASE_P(
     ReplayAfterEOS,
     VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 4, END_OF_STREAM_RESET, CS_RESET, false, false)));
+        std::make_tuple(1, 1, 4, END_OF_STREAM_RESET, CS_RESET, false, false)));
 
 // Test that Reset() before the first Decode() works fine.
-INSTANTIATE_TEST_CASE_P(
-    ResetBeforeDecode,
-    VideoDecodeAcceleratorParamTest,
-    ::testing::Values(
-        MakeTuple(1, 1, 1, START_OF_STREAM_RESET, CS_RESET, false, false)));
+INSTANTIATE_TEST_CASE_P(ResetBeforeDecode,
+                        VideoDecodeAcceleratorParamTest,
+                        ::testing::Values(std::make_tuple(1,
+                                                          1,
+                                                          1,
+                                                          START_OF_STREAM_RESET,
+                                                          CS_RESET,
+                                                          false,
+                                                          false)));
 
 // Test Reset() immediately after Decode() containing config info.
 INSTANTIATE_TEST_CASE_P(
     ResetAfterFirstConfigInfo,
     VideoDecodeAcceleratorParamTest,
-    ::testing::Values(MakeTuple(1,
-                                1,
-                                1,
-                                RESET_AFTER_FIRST_CONFIG_INFO,
-                                CS_RESET,
-                                false,
-                                false)));
+    ::testing::Values(std::make_tuple(1,
+                                      1,
+                                      1,
+                                      RESET_AFTER_FIRST_CONFIG_INFO,
+                                      CS_RESET,
+                                      false,
+                                      false)));
 
 // Test that Reset() mid-stream works fine and doesn't affect decoding even when
 // Decode() calls are made during the reset.
 INSTANTIATE_TEST_CASE_P(
     MidStreamReset,
     VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, MID_STREAM_RESET, CS_RESET, false, false)));
+        std::make_tuple(1, 1, 1, MID_STREAM_RESET, CS_RESET, false, false)));
 
 INSTANTIATE_TEST_CASE_P(
     SlowRendering,
     VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, true, false)));
+        std::make_tuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, true, false)));
 
 // Test that Destroy() mid-stream works fine (primarily this is testing that no
 // crashes occur).
 INSTANTIATE_TEST_CASE_P(
     TearDownTiming,
     VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_DECODER_SET, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_INITIALIZED, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHING, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHED, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESETTING, false, false),
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
-        MakeTuple(1,
-                  1,
-                  1,
-                  END_OF_STREAM_RESET,
-                  static_cast<ClientState>(-1),
-                  false,
-                  false),
-        MakeTuple(1,
-                  1,
-                  1,
-                  END_OF_STREAM_RESET,
-                  static_cast<ClientState>(-10),
-                  false,
-                  false),
-        MakeTuple(1,
-                  1,
-                  1,
-                  END_OF_STREAM_RESET,
-                  static_cast<ClientState>(-100),
-                  false,
-                  false)));
+        std::make_tuple(1,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        CS_DECODER_SET,
+                        false,
+                        false),
+        std::make_tuple(1,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        CS_INITIALIZED,
+                        false,
+                        false),
+        std::make_tuple(1,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        CS_FLUSHING,
+                        false,
+                        false),
+        std::make_tuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHED, false, false),
+        std::make_tuple(1,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        CS_RESETTING,
+                        false,
+                        false),
+        std::make_tuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
+        std::make_tuple(1,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        static_cast<ClientState>(-1),
+                        false,
+                        false),
+        std::make_tuple(1,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        static_cast<ClientState>(-10),
+                        false,
+                        false),
+        std::make_tuple(1,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        static_cast<ClientState>(-100),
+                        false,
+                        false)));
 
 // Test that decoding various variation works with multiple in-flight decodes.
 INSTANTIATE_TEST_CASE_P(
     DecodeVariations,
     VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
-        MakeTuple(1, 10, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
+        std::make_tuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
+        std::make_tuple(1, 10, 1, END_OF_STREAM_RESET, CS_RESET, false, false),
         // Tests queuing.
-        MakeTuple(1, 15, 1, END_OF_STREAM_RESET, CS_RESET, false, false)));
+        std::make_tuple(1,
+                        15,
+                        1,
+                        END_OF_STREAM_RESET,
+                        CS_RESET,
+                        false,
+                        false)));
 
 // Find out how many concurrent decoders can go before we exhaust system
 // resources.
-INSTANTIATE_TEST_CASE_P(ResourceExhaustion,
-                        VideoDecodeAcceleratorParamTest,
-                        ::testing::Values(
-                            // +0 hack below to promote enum to int.
-                            MakeTuple(kMinSupportedNumConcurrentDecoders + 0,
-                                      1,
-                                      1,
-                                      END_OF_STREAM_RESET,
-                                      CS_RESET,
-                                      false,
-                                      false),
-                            MakeTuple(kMinSupportedNumConcurrentDecoders + 1,
-                                      1,
-                                      1,
-                                      END_OF_STREAM_RESET,
-                                      CS_RESET,
-                                      false,
-                                      false)));
+INSTANTIATE_TEST_CASE_P(
+    ResourceExhaustion,
+    VideoDecodeAcceleratorParamTest,
+    ::testing::Values(
+        // +0 hack below to promote enum to int.
+        std::make_tuple(kMinSupportedNumConcurrentDecoders + 0,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        CS_RESET,
+                        false,
+                        false),
+        std::make_tuple(kMinSupportedNumConcurrentDecoders + 1,
+                        1,
+                        1,
+                        END_OF_STREAM_RESET,
+                        CS_RESET,
+                        false,
+                        false)));
 
 // Thumbnailing test
 INSTANTIATE_TEST_CASE_P(
     Thumbnail,
     VideoDecodeAcceleratorParamTest,
     ::testing::Values(
-        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, true)));
+        std::make_tuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, true)));
 
 // Measure the median of the decode time when VDA::Decode is called 30 times per
 // second.
 TEST_F(VideoDecodeAcceleratorTest, TestDecodeTimeMedian) {
   RenderingHelperParams helper_params;
 
   // Disable rendering by setting the rendering_fps = 0.
   helper_params.rendering_fps = 0;
   helper_params.warm_up_iterations = 0;
   helper_params.render_as_thumbnails = false;
@@ skipping 127 matching lines @@
   media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   media::g_env =
       reinterpret_cast<media::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }