Move Tuple to base namespace.

content/common/gpu/media/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
@@ skipping 64 matching lines @@
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_gpu_test_helper.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif  // defined(USE_OZONE)
 
 using media::VideoDecodeAccelerator;
 
 namespace content {
 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 1075 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<
-        Tuple<int, int, int, ResetPoint, ClientState, bool, bool> > {
+        base::Tuple<int, int, int, ResetPoint, ClientState, bool, bool> > {
 };
 
 // Helper so that gtest failures emit a more readable version of the tuple than
 // its byte representation.
 ::std::ostream& operator<<(
     ::std::ostream& os,
-    const Tuple<int, int, int, ResetPoint, ClientState, bool, bool>& t) {
-  return os << get<0>(t) << ", " << get<1>(t) << ", " << get<2>(t) << ", "
-            << get<3>(t) << ", " << get<4>(t) << ", " << get<5>(t) << ", "
-            << get<6>(t);
+    const base::Tuple<int, int, int, ResetPoint, ClientState, bool, bool>& t) {
+  return os << base::get<0>(t) << ", " << base::get<1>(t) << ", "
+            << base::get<2>(t) << ", " << base::get<3>(t) << ", "
+            << base::get<4>(t) << ", " << base::get<5>(t) << ", "
+            << base::get<6>(t);
 }
 
 // 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 = get<0>(GetParam());
-  const size_t num_in_flight_decodes = get<1>(GetParam());
-  int num_play_throughs = get<2>(GetParam());
-  const int reset_point = get<3>(GetParam());
-  const int delete_decoder_state = get<4>(GetParam());
-  bool test_reuse_delay = get<5>(GetParam());
-  const bool render_as_thumbnails = get<6>(GetParam());
+  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());
 
   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 406 matching lines @@
   content::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   content::g_env =
       reinterpret_cast<content::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }