Test X11 header pollution

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
@@ skipping 30 matching lines @@
 #include "base/strings/string_split.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
-#include "content/common/gpu/media/fake_video_decode_accelerator.h"
-#include "content/common/gpu/media/gpu_video_decode_accelerator_factory_impl.h"
-#include "content/common/gpu/media/rendering_helper.h"
-#include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "media/filters/h264_parser.h"
+#include "media/gpu/fake_video_decode_accelerator.h"
+#include "media/gpu/gpu_video_decode_accelerator_factory_impl.h"
+#include "media/gpu/rendering_helper.h"
+#include "media/gpu/video_accelerator_unittest_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gl/gl_image.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
-#include "content/common/gpu/media/dxva_video_decode_accelerator_win.h"
+#include "media/gpu/dxva_video_decode_accelerator_win.h"
 #elif defined(OS_CHROMEOS)
 #if defined(USE_V4L2_CODEC)
-#include "content/common/gpu/media/v4l2_device.h"
-#include "content/common/gpu/media/v4l2_slice_video_decode_accelerator.h"
-#include "content/common/gpu/media/v4l2_video_decode_accelerator.h"
+#include "media/gpu/v4l2_device.h"
+#include "media/gpu/v4l2_slice_video_decode_accelerator.h"
+#include "media/gpu/v4l2_video_decode_accelerator.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
-#include "content/common/gpu/media/vaapi_video_decode_accelerator.h"
-#include "content/common/gpu/media/vaapi_wrapper.h"
+#include "media/gpu/vaapi_video_decode_accelerator.h"
+#include "media/gpu/vaapi_wrapper.h"
 #endif  // defined(ARCH_CPU_X86_FAMILY)
 #else
 #error The VideoAccelerator tests are not supported on this platform.
 #endif  // OS_WIN
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/native_pixmap.h"
 #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 content {
+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:
@@ skipping 61 matching lines @@
 struct TestVideoFile {
   explicit TestVideoFile(base::FilePath::StringType file_name)
       : file_name(file_name),
         width(-1),
         height(-1),
         num_frames(-1),
         num_fragments(-1),
         min_fps_render(-1),
         min_fps_no_render(-1),
         profile(media::VIDEO_CODEC_PROFILE_UNKNOWN),
-        reset_after_frame_num(END_OF_STREAM_RESET) {
-  }
+        reset_after_frame_num(END_OF_STREAM_RESET) {}
 
   base::FilePath::StringType file_name;
   int width;
   int height;
   int num_frames;
   int num_fragments;
   int min_fps_render;
   int min_fps_no_render;
   media::VideoCodecProfile profile;
   int reset_after_frame_num;
   std::string data_str;
 };
 
 const gfx::Size kThumbnailsPageSize(1600, 1200);
 const gfx::Size kThumbnailSize(160, 120);
 const int kMD5StringLength = 32;
 
 // Read in golden MD5s for the thumbnailed rendering of this video
 void ReadGoldenThumbnailMD5s(const TestVideoFile* video_file,
                              std::vector<std::string>* md5_strings) {
   base::FilePath filepath(video_file->file_name);
   filepath = filepath.AddExtension(FILE_PATH_LITERAL(".md5"));
   std::string all_md5s;
   base::ReadFileToString(filepath, &all_md5s);
-  *md5_strings = base::SplitString(
-      all_md5s, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  *md5_strings = base::SplitString(all_md5s, "\n", base::TRIM_WHITESPACE,
+                                   base::SPLIT_WANT_ALL);
   // Check these are legitimate MD5s.
   for (const std::string& md5_string : *md5_strings) {
-      // Ignore the empty string added by SplitString
-      if (!md5_string.length())
-        continue;
-      // Ignore comments
-      if (md5_string.at(0) == '#')
-        continue;
+    // Ignore the empty string added by SplitString
+    if (!md5_string.length())
+      continue;
+    // Ignore comments
+    if (md5_string.at(0) == '#')
+      continue;
 
-      LOG_ASSERT(static_cast<int>(md5_string.length()) ==
-               kMD5StringLength) << md5_string;
-      bool hex_only = std::count_if(md5_string.begin(),
-                                    md5_string.end(), isxdigit) ==
-                                    kMD5StringLength;
-      LOG_ASSERT(hex_only) << md5_string;
+    LOG_ASSERT(static_cast<int>(md5_string.length()) == kMD5StringLength)
+        << md5_string;
+    bool hex_only = std::count_if(md5_string.begin(), md5_string.end(),
+                                  isxdigit) == kMD5StringLength;
+    LOG_ASSERT(hex_only) << md5_string;
   }
   LOG_ASSERT(md5_strings->size() >= 1U) << "  MD5 checksum file ("
-                                    << filepath.MaybeAsASCII()
-                                    << ") missing or empty.";
+                                        << filepath.MaybeAsASCII()
+                                        << ") missing or empty.";
 }
 
 // State of the GLRenderingVDAClient below.  Order matters here as the test
 // makes assumptions about it.
 enum ClientState {
   CS_CREATED = 0,
   CS_DECODER_SET = 1,
   CS_INITIALIZED = 2,
   CS_FLUSHING = 3,
   CS_FLUSHED = 4,
@@ skipping 232 matching lines @@
 
   // Compute & return the first encoded bytes (including a start frame) to send
   // to the decoder, starting at |start_pos| and returning one fragment. Skips
   // to the first decodable position.
   std::string GetBytesForFirstFragment(size_t start_pos, size_t* end_pos);
   // Compute & return the encoded bytes of next fragment to send to the decoder
   // (based on |start_pos|).
   std::string GetBytesForNextFragment(size_t start_pos, size_t* end_pos);
   // Helpers for GetBytesForNextFragment above.
   void GetBytesForNextNALU(size_t start_pos, size_t* end_pos);  // For h.264.
-  std::string GetBytesForNextFrame(
-      size_t start_pos, size_t* end_pos);  // For VP8/9.
+  std::string GetBytesForNextFrame(size_t start_pos,
+                                   size_t* end_pos);  // For VP8/9.
 
   // Request decode of the next fragment in the encoded data.
   void DecodeNextFragment();
 
   size_t window_id_;
   RenderingHelper* rendering_helper_;
   gfx::Size frame_size_;
   std::string encoded_data_;
   const int num_in_flight_decodes_;
   int outstanding_decodes_;
@@ skipping 169 matching lines @@
     return;
   LOG_ASSERT(textures_per_buffer == 1u);
   std::vector<media::PictureBuffer> buffers;
 
   requested_num_of_buffers += kExtraPictureBuffers;
 
   texture_target_ = texture_target;
   for (uint32_t i = 0; i < requested_num_of_buffers; ++i) {
     uint32_t texture_id;
     base::WaitableEvent done(false, false);
-    rendering_helper_->CreateTexture(
-        texture_target_, &texture_id, dimensions, &done);
+    rendering_helper_->CreateTexture(texture_target_, &texture_id, dimensions,
+                                     &done);
     done.Wait();
 
     scoped_refptr<TextureRef> texture_ref;
     base::Closure delete_texture_cb =
         base::Bind(&RenderingHelper::DeleteTexture,
                    base::Unretained(rendering_helper_), texture_id);
 
     if (g_test_import) {
       media::VideoPixelFormat pixel_format = decoder_->GetOutputFormat();
       if (pixel_format == media::PIXEL_FORMAT_UNKNOWN)
@@ skipping 174 matching lines @@
 void GLRenderingVDAClient::NotifyError(VideoDecodeAccelerator::Error error) {
   SetState(CS_ERROR);
 }
 
 void GLRenderingVDAClient::OutputFrameDeliveryTimes(base::File* output) {
   std::string s = base::StringPrintf("frame count: %" PRIuS "\n",
                                      frame_delivery_times_.size());
   output->WriteAtCurrentPos(s.data(), s.length());
   base::TimeTicks t0 = initialize_done_ticks_;
   for (size_t i = 0; i < frame_delivery_times_.size(); ++i) {
-    s = base::StringPrintf("frame %04" PRIuS ": %" PRId64 " us\n",
-                           i,
+    s = base::StringPrintf("frame %04" PRIuS ": %" PRId64 " us\n", i,
                            (frame_delivery_times_[i] - t0).InMicroseconds());
     t0 = frame_delivery_times_[i];
     output->WriteAtCurrentPos(s.data(), s.length());
   }
 }
 
 static bool LookingAtNAL(const std::string& encoded, size_t pos) {
-  return encoded[pos] == 0 && encoded[pos + 1] == 0 &&
-      encoded[pos + 2] == 0 && encoded[pos + 3] == 1;
+  return encoded[pos] == 0 && encoded[pos + 1] == 0 && encoded[pos + 2] == 0 &&
+         encoded[pos + 3] == 1;
 }
 
 void GLRenderingVDAClient::SetState(ClientState new_state) {
   note_->Notify(new_state);
   state_ = new_state;
   if (!remaining_play_throughs_ && new_state == delete_decoder_state_) {
     LOG_ASSERT(!decoder_deleted());
     DeleteDecoder();
   }
 }
@@ skipping 19 matching lines @@
   weak_vda_ptr_factory_->InvalidateWeakPtrs();
   decoder_.reset();
   STLClearObject(&encoded_data_);
   active_textures_.clear();
 
   // Cascade through the rest of the states to simplify test code below.
   for (int i = state_ + 1; i < CS_MAX; ++i)
     SetState(static_cast<ClientState>(i));
 }
 
-std::string GLRenderingVDAClient::GetBytesForFirstFragment(
-    size_t start_pos, size_t* end_pos) {
+std::string GLRenderingVDAClient::GetBytesForFirstFragment(size_t start_pos,
+                                                           size_t* end_pos) {
   if (profile_ < media::H264PROFILE_MAX) {
     *end_pos = start_pos;
     while (*end_pos + 4 < encoded_data_.size()) {
-      if ((encoded_data_[*end_pos + 4] & 0x1f) == 0x7) // SPS start frame
+      if ((encoded_data_[*end_pos + 4] & 0x1f) == 0x7)  // SPS start frame
         return GetBytesForNextFragment(*end_pos, end_pos);
       GetBytesForNextNALU(*end_pos, end_pos);
       num_skipped_fragments_++;
     }
     *end_pos = start_pos;
     return std::string();
   }
   DCHECK_LE(profile_, media::VP9PROFILE_MAX);
   return GetBytesForNextFragment(start_pos, end_pos);
 }
 
-std::string GLRenderingVDAClient::GetBytesForNextFragment(
-    size_t start_pos, size_t* end_pos) {
+std::string GLRenderingVDAClient::GetBytesForNextFragment(size_t start_pos,
+                                                          size_t* end_pos) {
   if (profile_ < media::H264PROFILE_MAX) {
     *end_pos = start_pos;
     GetBytesForNextNALU(*end_pos, end_pos);
     if (start_pos != *end_pos) {
       num_queued_fragments_++;
     }
     return encoded_data_.substr(start_pos, *end_pos - start_pos);
   }
   DCHECK_LE(profile_, media::VP9PROFILE_MAX);
   return GetBytesForNextFrame(start_pos, end_pos);
 }
 
-void GLRenderingVDAClient::GetBytesForNextNALU(
-    size_t start_pos, size_t* end_pos) {
+void GLRenderingVDAClient::GetBytesForNextNALU(size_t start_pos,
+                                               size_t* end_pos) {
   *end_pos = start_pos;
   if (*end_pos + 4 > encoded_data_.size())
     return;
   LOG_ASSERT(LookingAtNAL(encoded_data_, start_pos));
   *end_pos += 4;
   while (*end_pos + 4 <= encoded_data_.size() &&
          !LookingAtNAL(encoded_data_, *end_pos)) {
     ++*end_pos;
   }
   if (*end_pos + 3 >= encoded_data_.size())
     *end_pos = encoded_data_.size();
 }
 
-std::string GLRenderingVDAClient::GetBytesForNextFrame(
-    size_t start_pos, size_t* end_pos) {
+std::string GLRenderingVDAClient::GetBytesForNextFrame(size_t start_pos,
+                                                       size_t* end_pos) {
   // Helpful description: http://wiki.multimedia.cx/index.php?title=IVF
   std::string bytes;
   if (start_pos == 0)
     start_pos = 32;  // Skip IVF header.
   *end_pos = start_pos;
   uint32_t frame_size = *reinterpret_cast<uint32_t*>(&encoded_data_[*end_pos]);
   *end_pos += 12;  // Skip frame header.
   bytes.append(encoded_data_.substr(*end_pos, frame_size));
   *end_pos += frame_size;
   num_queued_fragments_++;
   return bytes;
 }
 
 static bool FragmentHasConfigInfo(const uint8_t* data,
                                   size_t size,
                                   media::VideoCodecProfile profile) {
-  if (profile >= media::H264PROFILE_MIN &&
-      profile <= media::H264PROFILE_MAX) {
+  if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
     media::H264Parser parser;
     parser.SetStream(data, size);
     media::H264NALU nalu;
     media::H264Parser::Result result = parser.AdvanceToNextNALU(&nalu);
     if (result != media::H264Parser::kOk) {
       // Let the VDA figure out there's something wrong with the stream.
       return false;
     }
 
     return nalu.nal_unit_type == media::H264NALU::kSPS;
@@ skipping 32 matching lines @@
     if (reset_here)
       reset_after_frame_num_ = END_OF_STREAM_RESET;
   }
 
   // Populate the shared memory buffer w/ the fragment, duplicate its handle,
   // and hand it off to the decoder.
   base::SharedMemory shm;
   LOG_ASSERT(shm.CreateAndMapAnonymous(next_fragment_size));
   memcpy(shm.memory(), next_fragment_bytes.data(), next_fragment_size);
   base::SharedMemoryHandle dup_handle;
-  bool result = shm.ShareToProcess(base::GetCurrentProcessHandle(),
-      &dup_handle);
+  bool result =
+      shm.ShareToProcess(base::GetCurrentProcessHandle(), &dup_handle);
   LOG_ASSERT(result);
-  media::BitstreamBuffer bitstream_buffer(
-      next_bitstream_buffer_id_, dup_handle, next_fragment_size);
+  media::BitstreamBuffer bitstream_buffer(next_bitstream_buffer_id_, dup_handle,
+                                          next_fragment_size);
   decode_start_time_[next_bitstream_buffer_id_] = base::TimeTicks::Now();
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
   decoder_->Decode(bitstream_buffer);
   ++outstanding_decodes_;
   if (!remaining_play_throughs_ &&
       -delete_decoder_state_ == next_bitstream_buffer_id_) {
     DeleteDecoder();
   }
 
@@ skipping 38 matching lines @@
 
   // Parse |data| into its constituent parts, set the various output fields
   // accordingly, and read in video stream. CHECK-fails on unexpected or
   // missing required data. Unspecified optional fields are set to -1.
   void ParseAndReadTestVideoData(base::FilePath::StringType data,
                                  std::vector<TestVideoFile*>* test_video_files);
 
   // Update the parameters of |test_video_files| according to
   // |num_concurrent_decoders| and |reset_point|. Ex: the expected number of
   // frames should be adjusted if decoder is reset in the middle of the stream.
-  void UpdateTestVideoFileParams(
-      size_t num_concurrent_decoders,
-      int reset_point,
-      std::vector<TestVideoFile*>* test_video_files);
+  void UpdateTestVideoFileParams(size_t num_concurrent_decoders,
+                                 int reset_point,
+                                 std::vector<TestVideoFile*>* test_video_files);
 
   void InitializeRenderingHelper(const RenderingHelperParams& helper_params);
   void CreateAndStartDecoder(GLRenderingVDAClient* client,
                              ClientStateNotification<ClientState>* note);
   void WaitUntilDecodeFinish(ClientStateNotification<ClientState>* note);
   void WaitUntilIdle();
   void OutputLogFile(const base::FilePath::CharType* log_path,
                      const std::string& content);
 
   std::vector<TestVideoFile*> test_video_files_;
   RenderingHelper rendering_helper_;
 
  private:
   // Required for Thread to work.  Not used otherwise.
   base::ShadowingAtExitManager at_exit_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoDecodeAcceleratorTest);
 };
 
-VideoDecodeAcceleratorTest::VideoDecodeAcceleratorTest() {
-}
+VideoDecodeAcceleratorTest::VideoDecodeAcceleratorTest() {}
 
 void VideoDecodeAcceleratorTest::SetUp() {
   ParseAndReadTestVideoData(g_test_video_data, &test_video_files_);
 }
 
 void VideoDecodeAcceleratorTest::TearDown() {
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&STLDeleteElements<std::vector<TestVideoFile*>>,
                             &test_video_files_));
 
   base::WaitableEvent done(false, false);
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&RenderingHelper::UnInitialize,
                             base::Unretained(&rendering_helper_), &done));
   done.Wait();
 
   rendering_helper_.TearDown();
 }
 
 void VideoDecodeAcceleratorTest::ParseAndReadTestVideoData(
     base::FilePath::StringType data,
     std::vector<TestVideoFile*>* test_video_files) {
-  std::vector<base::FilePath::StringType> entries = base::SplitString(
-      data, base::FilePath::StringType(1, ';'),
-      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<base::FilePath::StringType> entries =
+      base::SplitString(data, base::FilePath::StringType(1, ';'),
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   LOG_ASSERT(entries.size() >= 1U) << data;
   for (size_t index = 0; index < entries.size(); ++index) {
-    std::vector<base::FilePath::StringType> fields = base::SplitString(
-        entries[index], base::FilePath::StringType(1, ':'),
-        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    std::vector<base::FilePath::StringType> fields =
+        base::SplitString(entries[index], base::FilePath::StringType(1, ':'),
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     LOG_ASSERT(fields.size() >= 1U) << entries[index];
     LOG_ASSERT(fields.size() <= 8U) << entries[index];
     TestVideoFile* video_file = new TestVideoFile(fields[0]);
     if (!fields[1].empty())
       LOG_ASSERT(base::StringToInt(fields[1], &video_file->width));
     if (!fields[2].empty())
       LOG_ASSERT(base::StringToInt(fields[2], &video_file->height));
     if (!fields[3].empty())
       LOG_ASSERT(base::StringToInt(fields[3], &video_file->num_frames));
     if (!fields[4].empty())
@@ skipping 92 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> > {
-};
+          base::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;
+  if (state == expected_state)
+    return;
   ASSERT_TRUE(client->decoder_deleted())
-      << "Decoder not deleted but Wait() returned " << state
-      << ", instead of " << expected_state;
+      << "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());
 
   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_);
+  UpdateTestVideoFileParams(num_concurrent_decoders, reset_point,
+                            &test_video_files_);
 
   // Suppress GL rendering for all tests when the "--rendering_fps" is 0.
   const bool suppress_rendering = g_rendering_fps == 0;
 
-  std::vector<ClientStateNotification<ClientState>*>
-      notes(num_concurrent_decoders, NULL);
+  std::vector<ClientStateNotification<ClientState>*> notes(
+      num_concurrent_decoders, NULL);
   std::vector<GLRenderingVDAClient*> clients(num_concurrent_decoders, NULL);
 
   RenderingHelperParams helper_params;
   helper_params.rendering_fps = g_rendering_fps;
   helper_params.warm_up_iterations = g_rendering_warm_up;
   helper_params.render_as_thumbnails = render_as_thumbnails;
   if (render_as_thumbnails) {
     // Only one decoder is supported with thumbnail rendering
     LOG_ASSERT(num_concurrent_decoders == 1U);
     helper_params.thumbnails_page_size = kThumbnailsPageSize;
     helper_params.thumbnail_size = kThumbnailSize;
   }
 
   // First kick off all the decoders.
   for (size_t index = 0; index < num_concurrent_decoders; ++index) {
     TestVideoFile* video_file =
         test_video_files_[index % test_video_files_.size()];
     ClientStateNotification<ClientState>* note =
         new ClientStateNotification<ClientState>();
     notes[index] = note;
 
     int delay_after_frame_num = std::numeric_limits<int>::max();
     if (test_reuse_delay &&
         kMaxFramesToDelayReuse * 2 < video_file->num_frames) {
       delay_after_frame_num = video_file->num_frames - kMaxFramesToDelayReuse;
     }
 
-    GLRenderingVDAClient* client =
-        new GLRenderingVDAClient(index,
-                                 &rendering_helper_,
-                                 note,
-                                 video_file->data_str,
-                                 num_in_flight_decodes,
-                                 num_play_throughs,
-                                 video_file->reset_after_frame_num,
-                                 delete_decoder_state,
-                                 video_file->width,
-                                 video_file->height,
-                                 video_file->profile,
-                                 g_fake_decoder,
-                                 suppress_rendering,
-                                 delay_after_frame_num,
-                                 0,
-                                 render_as_thumbnails);
+    GLRenderingVDAClient* client = new GLRenderingVDAClient(
+        index, &rendering_helper_, note, video_file->data_str,
+        num_in_flight_decodes, num_play_throughs,
+        video_file->reset_after_frame_num, delete_decoder_state,
+        video_file->width, video_file->height, video_file->profile,
+        g_fake_decoder, suppress_rendering, delay_after_frame_num, 0,
+        render_as_thumbnails);
 
     clients[index] = client;
     helper_params.window_sizes.push_back(
         render_as_thumbnails
             ? kThumbnailsPageSize
             : gfx::Size(video_file->width, video_file->height));
   }
 
   InitializeRenderingHelper(helper_params);
 
@@ skipping 34 matching lines @@
       ASSERT_NO_FATAL_FAILURE(
           AssertWaitForStateOrDeleted(note, clients[i], CS_RESETTING));
     }
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_RESET));
     // ResetDone requests Destroy().
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_DESTROYED));
   }
   // Finally assert that decoding went as expected.
-  for (size_t i = 0; i < num_concurrent_decoders &&
-           !skip_performance_and_correctness_checks; ++i) {
+  for (size_t i = 0;
+       i < num_concurrent_decoders && !skip_performance_and_correctness_checks;
+       ++i) {
     // We can only make performance/correctness assertions if the decoder was
     // allowed to finish.
     if (delete_decoder_state < CS_FLUSHED)
       continue;
     GLRenderingVDAClient* client = clients[i];
     TestVideoFile* video_file = test_video_files_[i % test_video_files_.size()];
     if (video_file->num_frames > 0) {
       // Expect the decoded frames may be more than the video frames as frames
       // could still be returned until resetting done.
       if (video_file->reset_after_frame_num > 0)
         EXPECT_GE(client->num_decoded_frames(), video_file->num_frames);
       else
         EXPECT_EQ(client->num_decoded_frames(), video_file->num_frames);
     }
     if (reset_point == END_OF_STREAM_RESET) {
       EXPECT_EQ(video_file->num_fragments, client->num_skipped_fragments() +
-                client->num_queued_fragments());
+                                               client->num_queued_fragments());
       EXPECT_EQ(client->num_done_bitstream_buffers(),
                 client->num_queued_fragments());
     }
     LOG(INFO) << "Decoder " << i << " fps: " << client->frames_per_second();
     if (!render_as_thumbnails) {
-      int min_fps = suppress_rendering ?
-          video_file->min_fps_no_render : video_file->min_fps_render;
+      int min_fps = suppress_rendering ? video_file->min_fps_no_render
+                                       : video_file->min_fps_render;
       if (min_fps > 0 && !test_reuse_delay)
         EXPECT_GT(client->frames_per_second(), min_fps);
     }
   }
 
   if (render_as_thumbnails) {
     std::vector<unsigned char> rgb;
     bool alpha_solid;
     base::WaitableEvent done(false, false);
     g_env->GetRenderingTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&RenderingHelper::GetThumbnailsAsRGB,
                               base::Unretained(&rendering_helper_), &rgb,
                               &alpha_solid, &done));
     done.Wait();
 
     std::vector<std::string> golden_md5s;
     std::string md5_string = base::MD5String(
         base::StringPiece(reinterpret_cast<char*>(&rgb[0]), rgb.size()));
     ReadGoldenThumbnailMD5s(test_video_files_[0], &golden_md5s);
     std::vector<std::string>::iterator match =
         find(golden_md5s.begin(), golden_md5s.end(), md5_string);
     if (match == golden_md5s.end()) {
       // Convert raw RGB into PNG for export.
       std::vector<unsigned char> png;
-      gfx::PNGCodec::Encode(&rgb[0],
-                            gfx::PNGCodec::FORMAT_RGB,
+      gfx::PNGCodec::Encode(&rgb[0], gfx::PNGCodec::FORMAT_RGB,
                             kThumbnailsPageSize,
-                            kThumbnailsPageSize.width() * 3,
-                            true,
-                            std::vector<gfx::PNGCodec::Comment>(),
-                            &png);
+                            kThumbnailsPageSize.width() * 3, true,
+                            std::vector<gfx::PNGCodec::Comment>(), &png);
 
       LOG(ERROR) << "Unknown thumbnails MD5: " << md5_string;
 
       base::FilePath filepath(test_video_files_[0]->file_name);
       filepath = filepath.AddExtension(FILE_PATH_LITERAL(".bad_thumbnails"));
       filepath = filepath.AddExtension(FILE_PATH_LITERAL(".png"));
-      int num_bytes = base::WriteFile(filepath,
-                                           reinterpret_cast<char*>(&png[0]),
-                                           png.size());
+      int num_bytes = base::WriteFile(
+          filepath, reinterpret_cast<char*>(&png[0]), png.size());
       ASSERT_EQ(num_bytes, static_cast<int>(png.size()));
     }
     ASSERT_NE(match, golden_md5s.end());
     EXPECT_EQ(alpha_solid, true) << "RGBA frame had incorrect alpha";
   }
 
   // Output the frame delivery time to file
   // We can only make performance/correctness assertions if the decoder was
   // allowed to finish.
   if (g_output_log != NULL && delete_decoder_state >= CS_FLUSHED) {
@@ skipping 12 matching lines @@
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&STLDeleteElements<
                      std::vector<ClientStateNotification<ClientState>*>>,
                  &notes));
   WaitUntilIdle();
 };
 
 // Test that replay after EOS works fine.
 INSTANTIATE_TEST_CASE_P(
-    ReplayAfterEOS, VideoDecodeAcceleratorParamTest,
+    ReplayAfterEOS,
+    VideoDecodeAcceleratorParamTest,
     ::testing::Values(
         MakeTuple(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,
+    ResetBeforeDecode,
+    VideoDecodeAcceleratorParamTest,
     ::testing::Values(
         MakeTuple(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)));
+    ResetAfterFirstConfigInfo,
+    VideoDecodeAcceleratorParamTest,
+    ::testing::Values(MakeTuple(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,
+    MidStreamReset,
+    VideoDecodeAcceleratorParamTest,
     ::testing::Values(
         MakeTuple(1, 1, 1, MID_STREAM_RESET, CS_RESET, false, false)));
 
 INSTANTIATE_TEST_CASE_P(
-    SlowRendering, VideoDecodeAcceleratorParamTest,
+    SlowRendering,
+    VideoDecodeAcceleratorParamTest,
     ::testing::Values(
         MakeTuple(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,
+    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)));
+        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)));
 
 // Test that decoding various variation works with multiple in-flight decodes.
 INSTANTIATE_TEST_CASE_P(
-    DecodeVariations, VideoDecodeAcceleratorParamTest,
+    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),
         // Tests queuing.
         MakeTuple(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.
+                            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)));
 
 // Thumbnailing test
 INSTANTIATE_TEST_CASE_P(
-    Thumbnail, VideoDecodeAcceleratorParamTest,
+    Thumbnail,
+    VideoDecodeAcceleratorParamTest,
     ::testing::Values(
         MakeTuple(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;
 
   ClientStateNotification<ClientState>* note =
       new ClientStateNotification<ClientState>();
-  GLRenderingVDAClient* client =
-      new GLRenderingVDAClient(0,
-                               &rendering_helper_,
-                               note,
-                               test_video_files_[0]->data_str,
-                               1,
-                               1,
-                               test_video_files_[0]->reset_after_frame_num,
-                               CS_RESET,
-                               test_video_files_[0]->width,
-                               test_video_files_[0]->height,
-                               test_video_files_[0]->profile,
-                               g_fake_decoder,
-                               true,
-                               std::numeric_limits<int>::max(),
-                               kWebRtcDecodeCallsPerSecond,
-                               false /* render_as_thumbnail */);
+  GLRenderingVDAClient* client = new GLRenderingVDAClient(
+      0, &rendering_helper_, note, test_video_files_[0]->data_str, 1, 1,
+      test_video_files_[0]->reset_after_frame_num, CS_RESET,
+      test_video_files_[0]->width, test_video_files_[0]->height,
+      test_video_files_[0]->profile, g_fake_decoder, true,
+      std::numeric_limits<int>::max(), kWebRtcDecodeCallsPerSecond,
+      false /* render_as_thumbnail */);
   helper_params.window_sizes.push_back(
       gfx::Size(test_video_files_[0]->width, test_video_files_[0]->height));
   InitializeRenderingHelper(helper_params);
   CreateAndStartDecoder(client, note);
   WaitUntilDecodeFinish(note);
 
   base::TimeDelta decode_time_median = client->decode_time_median();
   std::string output_string =
       base::StringPrintf("Decode time median: %" PRId64 " us",
                          decode_time_median.InMicroseconds());
   LOG(INFO) << output_string;
 
   if (g_output_log != NULL)
     OutputLogFile(g_output_log, output_string);
 
   g_env->GetRenderingTaskRunner()->DeleteSoon(FROM_HERE, client);
   g_env->GetRenderingTaskRunner()->DeleteSoon(FROM_HERE, note);
   WaitUntilIdle();
 };
 
 // TODO(fischman, vrk): add more tests!  In particular:
 // - Test life-cycle: Seek/Stop/Pause/Play for a single decoder.
 // - Test alternate configurations
 // - Test failure conditions.
 // - Test frame size changes mid-stream
 
 }  // namespace
-}  // namespace content
+}  // namespace media
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
   base::CommandLine::Init(argc, argv);
 
   // Needed to enable DVLOG through --vmodule.
   logging::LoggingSettings settings;
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
   LOG_ASSERT(logging::InitLogging(settings));
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   DCHECK(cmd_line);
 
   base::CommandLine::SwitchMap switches = cmd_line->GetSwitches();
   for (base::CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     if (it->first == "test_video_data") {
-      content::g_test_video_data = it->second.c_str();
+      media::g_test_video_data = it->second.c_str();
       continue;
     }
     // The output log for VDA performance test.
     if (it->first == "output_log") {
-      content::g_output_log = it->second.c_str();
+      media::g_output_log = it->second.c_str();
       continue;
     }
     if (it->first == "rendering_fps") {
       // On Windows, CommandLine::StringType is wstring. We need to convert
       // it to std::string first
       std::string input(it->second.begin(), it->second.end());
-      LOG_ASSERT(base::StringToDouble(input, &content::g_rendering_fps));
+      LOG_ASSERT(base::StringToDouble(input, &media::g_rendering_fps));
       continue;
     }
     if (it->first == "rendering_warm_up") {
       std::string input(it->second.begin(), it->second.end());
-      LOG_ASSERT(base::StringToInt(input, &content::g_rendering_warm_up));
+      LOG_ASSERT(base::StringToInt(input, &media::g_rendering_warm_up));
       continue;
     }
     // TODO(owenlin): Remove this flag once it is not used in autotest.
     if (it->first == "disable_rendering") {
-      content::g_rendering_fps = 0;
+      media::g_rendering_fps = 0;
       continue;
     }
 
     if (it->first == "num_play_throughs") {
       std::string input(it->second.begin(), it->second.end());
-      LOG_ASSERT(base::StringToInt(input, &content::g_num_play_throughs));
+      LOG_ASSERT(base::StringToInt(input, &media::g_num_play_throughs));
       continue;
     }
     if (it->first == "fake_decoder") {
-      content::g_fake_decoder = 1;
+      media::g_fake_decoder = 1;
       continue;
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     if (it->first == "ozone-platform" || it->first == "ozone-use-surfaceless")
       continue;
     if (it->first == "test_import") {
-      content::g_test_import = true;
+      media::g_test_import = true;
       continue;
     }
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
 #if defined(OS_WIN) || defined(USE_OZONE)
   // For windows the decoding thread initializes the media foundation decoder
   // which uses COM. We need the thread to be a UI thread.
   // On Ozone, the backend initializes the event system using a UI
   // thread.
   base::MessageLoopForUI main_loop;
 #else
   base::MessageLoop main_loop;
 #endif  // OS_WIN || USE_OZONE
 
 #if defined(USE_OZONE)
   ui::OzonePlatform::InitializeForUI();
 #endif
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  content::VaapiWrapper::PreSandboxInitialization();
+  media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
-  content::g_env =
-      reinterpret_cast<content::VideoDecodeAcceleratorTestEnvironment*>(
+  media::g_env =
+      reinterpret_cast<media::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
-              new content::VideoDecodeAcceleratorTestEnvironment()));
+              new media::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }