Add support for VP8 decode to OmxVideoDecodeAccelerator, for HW that supports it.

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 42 matching lines @@
 #error The VideoAccelerator tests are not supported on this platform.
 #endif  // defined(OS_WIN)
 
 using media::VideoDecodeAccelerator;
 using video_test_util::RenderingHelper;
 
 namespace {
 
 // Values optionally filled in from flags; see main() below.
 // The syntax of this variable is:
-//   filename:width:height:numframes:numNALUs:minFPSwithRender:minFPSnoRender
+//  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.
+// - |filename| must be an h264 Annex B (NAL) stream or an IVF VP8 stream.
 // - |width| and |height| are in pixels.
 // - |numframes| is the number of picture frames in the file.
-// - |numNALUs| is the number of NAL units in the stream.
+// - |numfragments| NALU (h264) or frame (VP8) count in the stream.
 // - |minFPSwithRender| and |minFPSnoRender| are minimum frames/second speeds
 //   expected to be achieved with and without rendering to the screen, resp.
 //   (the latter tests just decode speed).
-// - |profile| is the media::H264Profile set during Initialization.
+// - |profile| is the media::VideoCodecProfile set during Initialization.
 // An empty value for a numeric field means "ignore".
 #if defined(OS_MACOSX)
 const FilePath::CharType* test_video_data =
     FILE_PATH_LITERAL("test-25fps_high.h264:1280:720:250:252:50:100:4");
 #else
+// TODO(fischman): figure out how to support multiple test videos per run (needs
+// to refactor where ParseTestVideoData is called).  For now just make it easy
+// to replace which file is used by commenting/uncommenting these lines:
 const FilePath::CharType* test_video_data =
+    // FILE_PATH_LITERAL("test-25fps.vp8:320:240:250:250:50:175:11");
     FILE_PATH_LITERAL("test-25fps.h264:320:240:250:258:50:175:1");
 #endif
 
 // Parse |data| into its constituent parts and set the various output fields
 // accordingly.  CHECK-fails on unexpected or missing required data.
 // Unspecified optional fields are set to -1.
 void ParseTestVideoData(FilePath::StringType data,
                         FilePath::StringType* file_name,
                         int* width, int* height,
                         int* num_frames,
-                        int* num_NALUs,
+                        int* num_fragments,
                         int* min_fps_render,
                         int* min_fps_no_render,
                         int* profile) {
   std::vector<FilePath::StringType> elements;
   base::SplitString(data, ':', &elements);
   CHECK_GE(elements.size(), 1U) << data;
   CHECK_LE(elements.size(), 8U) << data;
   *file_name = elements[0];
-  *width = *height = *num_frames = *num_NALUs = -1;
+  *width = *height = *num_frames = *num_fragments = -1;
   *min_fps_render = *min_fps_no_render = -1;
   *profile = -1;
   if (!elements[1].empty())
     CHECK(base::StringToInt(elements[1], width));
   if (!elements[2].empty())
     CHECK(base::StringToInt(elements[2], height));
   if (!elements[3].empty())
     CHECK(base::StringToInt(elements[3], num_frames));
   if (!elements[4].empty())
-    CHECK(base::StringToInt(elements[4], num_NALUs));
+    CHECK(base::StringToInt(elements[4], num_fragments));
   if (!elements[5].empty())
     CHECK(base::StringToInt(elements[5], min_fps_render));
   if (!elements[6].empty())
     CHECK(base::StringToInt(elements[6], min_fps_no_render));
   if (!elements[7].empty())
     CHECK(base::StringToInt(elements[7], profile));
 }
 
 // State of the GLRenderingVDAClient below.  Order matters here as the test
 // makes assumptions about it.
@@ skipping 55 matching lines @@
   MID_STREAM_RESET = -2,
   END_OF_STREAM_RESET = -1
 };
 
 // Client that can accept callbacks from a VideoDecodeAccelerator and is used by
 // the TESTs below.
 class GLRenderingVDAClient : public VideoDecodeAccelerator::Client {
  public:
   // Doesn't take ownership of |rendering_helper| or |note|, which must outlive
   // |*this|.
+  // |num_fragments_per_decode| counts NALUs for h264 and frames for VP8.
   // |num_play_throughs| indicates how many times to play through the video.
   // |reset_after_frame_num| can be a frame number >=0 indicating a mid-stream
   // Reset() should be done after that frame number is delivered, or
   // END_OF_STREAM_RESET to indicate no mid-stream Reset().
   // |delete_decoder_state| indicates when the underlying decoder should be
   // Destroy()'d and deleted and can take values: N<0: delete after -N Decode()
   // calls have been made, N>=0 means interpret as ClientState.
   // Both |reset_after_frame_num| & |delete_decoder_state| apply only to the
   // last play-through (governed by |num_play_throughs|).
   GLRenderingVDAClient(RenderingHelper* rendering_helper,
                         int rendering_window_id,
                         ClientStateNotification* note,
                         const std::string& encoded_data,
-                        int num_NALUs_per_decode,
+                        int num_fragments_per_decode,
                         int num_in_flight_decodes,
                         int num_play_throughs,
                         int reset_after_frame_num,
                         int delete_decoder_state,
                         int frame_width,
                         int frame_height,
                         int profile);
   virtual ~GLRenderingVDAClient();
   void CreateDecoder();
 
@@ skipping 19 matching lines @@
   bool decoder_deleted() { return !decoder_.get(); }
 
  private:
   typedef std::map<int, media::PictureBuffer*> PictureBufferById;
 
   void SetState(ClientState new_state);
 
   // Delete the associated OMX decoder helper.
   void DeleteDecoder();
 
-  // Compute & return in |*end_pos| the end position for the next batch of NALUs
-  // to ship to the decoder (based on |start_pos| & |num_NALUs_per_decode_|).
-  void GetRangeForNextNALUs(size_t start_pos, size_t* end_pos);
+  // Compute & return in |*end_pos| the end position for the next batch of
+  // fragments to ship to the decoder (based on |start_pos| &
+  // |num_fragments_per_decode_|).
+  void GetRangeForNextFragments(size_t start_pos, size_t* end_pos);
+  // Helpers for GetRangeForNextFragments above.
+  void GetRangeForNextNALUs(size_t start_pos, size_t* end_pos);  // For h.264.
+  void GetRangeForNextFrames(size_t start_pos, size_t* end_pos);  // For VP8.
 
-  // Request decode of the next batch of NALUs in the encoded data.
-  void DecodeNextNALUs();
+  // Request decode of the next batch of fragments in the encoded data.
+  void DecodeNextFragments();
 
   RenderingHelper* rendering_helper_;
   int rendering_window_id_;
   std::string encoded_data_;
-  const int num_NALUs_per_decode_;
+  const int num_fragments_per_decode_;
   const int num_in_flight_decodes_;
   int outstanding_decodes_;
   size_t encoded_data_next_pos_to_decode_;
   int next_bitstream_buffer_id_;
   ClientStateNotification* note_;
   scoped_ptr<VideoDecodeAccelerator> decoder_;
   std::set<int> outstanding_texture_ids_;
   int remaining_play_throughs_;
   int reset_after_frame_num_;
   int delete_decoder_state_;
   ClientState state_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   PictureBufferById picture_buffers_by_id_;
   base::TimeTicks initialize_done_ticks_;
   base::TimeTicks last_frame_delivered_ticks_;
   int profile_;
 };
 
 GLRenderingVDAClient::GLRenderingVDAClient(
     RenderingHelper* rendering_helper,
     int rendering_window_id,
     ClientStateNotification* note,
     const std::string& encoded_data,
-    int num_NALUs_per_decode,
+    int num_fragments_per_decode,
     int num_in_flight_decodes,
     int num_play_throughs,
     int reset_after_frame_num,
     int delete_decoder_state,
     int frame_width,
     int frame_height,
     int profile)
     : rendering_helper_(rendering_helper),
       rendering_window_id_(rendering_window_id),
-      encoded_data_(encoded_data), num_NALUs_per_decode_(num_NALUs_per_decode),
+      encoded_data_(encoded_data),
+      num_fragments_per_decode_(num_fragments_per_decode),
       num_in_flight_decodes_(num_in_flight_decodes), outstanding_decodes_(0),
       encoded_data_next_pos_to_decode_(0), next_bitstream_buffer_id_(0),
       note_(note),
       remaining_play_throughs_(num_play_throughs),
       reset_after_frame_num_(reset_after_frame_num),
       delete_decoder_state_(delete_decoder_state),
       state_(CS_CREATED),
       num_decoded_frames_(0), num_done_bitstream_buffers_(0),
       profile_(profile) {
-  CHECK_GT(num_NALUs_per_decode, 0);
+  CHECK_GT(num_fragments_per_decode, 0);
   CHECK_GT(num_in_flight_decodes, 0);
   CHECK_GT(num_play_throughs, 0);
 }
 
 GLRenderingVDAClient::~GLRenderingVDAClient() {
   DeleteDecoder();  // Clean up in case of expected error.
   CHECK(decoder_deleted());
   STLDeleteValues(&picture_buffers_by_id_);
   SetState(CS_DESTROYED);
 }
@@ skipping 72 matching lines @@
 }
 
 void GLRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   CHECK_LT(state_, CS_RESET);
 
   if (decoder_deleted())
     return;
   last_frame_delivered_ticks_ = base::TimeTicks::Now();
 
-  // Because we feed the decoder a limited number of NALUs at a time, we can be
-  // sure that the bitstream buffer from which a frame comes has a limited
+  // Because we feed the decoder a limited number of fragments at a time, we can
+  // be sure that the bitstream buffer from which a frame comes has a limited
   // range.  Assert that.
-  CHECK_GE((picture.bitstream_buffer_id() + 1) * num_NALUs_per_decode_,
+  CHECK_GE((picture.bitstream_buffer_id() + 1) * num_fragments_per_decode_,
            num_decoded_frames_);
   CHECK_LE(picture.bitstream_buffer_id(), next_bitstream_buffer_id_);
   ++num_decoded_frames_;
 
   // Mid-stream reset applies only to the last play-through per constructor
   // comment.
   if (remaining_play_throughs_ == 1 &&
       reset_after_frame_num_ == num_decoded_frames_) {
     reset_after_frame_num_ = MID_STREAM_RESET;
     decoder_->Reset();
     // Re-start decoding from the beginning of the stream to avoid needing to
     // know how to find I-frames and so on in this test.
     encoded_data_next_pos_to_decode_ = 0;
   }
 
   media::PictureBuffer* picture_buffer =
       picture_buffers_by_id_[picture.picture_buffer_id()];
   CHECK(picture_buffer);
   rendering_helper_->RenderTexture(picture_buffer->texture_id());
 
   decoder_->ReusePictureBuffer(picture.picture_buffer_id());
 }
 
 void GLRenderingVDAClient::NotifyInitializeDone() {
   SetState(CS_INITIALIZED);
   initialize_done_ticks_ = base::TimeTicks::Now();
   for (int i = 0; i < num_in_flight_decodes_; ++i)
-    DecodeNextNALUs();
+    DecodeNextFragments();
   DCHECK_EQ(outstanding_decodes_, num_in_flight_decodes_);
 }
 
 void GLRenderingVDAClient::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   // TODO(fischman): this test currently relies on this notification to make
   // forward progress during a Reset().  But the VDA::Reset() API doesn't
   // guarantee this, so stop relying on it (and remove the notifications from
   // VaapiVideoDecodeAccelerator::FinishReset()).
   ++num_done_bitstream_buffers_;
   --outstanding_decodes_;
-  DecodeNextNALUs();
+  DecodeNextFragments();
 }
 
 void GLRenderingVDAClient::NotifyFlushDone() {
   if (decoder_deleted())
     return;
   SetState(CS_FLUSHED);
   --remaining_play_throughs_;
   DCHECK_GE(remaining_play_throughs_, 0);
   if (decoder_deleted())
     return;
   decoder_->Reset();
   SetState(CS_RESETTING);
 }
 
 void GLRenderingVDAClient::NotifyResetDone() {
   if (decoder_deleted())
     return;
 
   if (reset_after_frame_num_ == MID_STREAM_RESET) {
     reset_after_frame_num_ = END_OF_STREAM_RESET;
-    DecodeNextNALUs();
+    DecodeNextFragments();
     return;
   }
 
   if (remaining_play_throughs_) {
     encoded_data_next_pos_to_decode_ = 0;
     NotifyInitializeDone();
     return;
   }
 
   SetState(CS_RESET);
@@ skipping 28 matching lines @@
   for (std::set<int>::iterator it = outstanding_texture_ids_.begin();
        it != outstanding_texture_ids_.end(); ++it) {
     rendering_helper_->DeleteTexture(*it);
   }
   outstanding_texture_ids_.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));
 }
 
+void GLRenderingVDAClient::GetRangeForNextFragments(
+    size_t start_pos, size_t* end_pos) {
+  if (profile_ < media::H264PROFILE_MAX) {
+    GetRangeForNextNALUs(start_pos, end_pos);
+    return;
+  }
+  DCHECK_LE(profile_, media::VP8PROFILE_MAX);
+  GetRangeForNextFrames(start_pos, end_pos);
+}
+
 void GLRenderingVDAClient::GetRangeForNextNALUs(
     size_t start_pos, size_t* end_pos) {
   *end_pos = start_pos;
   CHECK(LookingAtNAL(encoded_data_, start_pos));
-  for (int i = 0; i < num_NALUs_per_decode_; ++i) {
+  for (int i = 0; i < num_fragments_per_decode_; ++i) {
     *end_pos += 4;
     while (*end_pos + 3 < encoded_data_.size() &&
            !LookingAtNAL(encoded_data_, *end_pos)) {
       ++*end_pos;
     }
     if (*end_pos + 3 >= encoded_data_.size()) {
       *end_pos = encoded_data_.size();
       return;
     }
   }
 }
 
-void GLRenderingVDAClient::DecodeNextNALUs() {
+void GLRenderingVDAClient::GetRangeForNextFrames(
+    size_t start_pos, size_t* end_pos) {
+  // Helpful description: http://wiki.multimedia.cx/index.php?title=IVF
+  *end_pos = start_pos;
+  if (start_pos == 0)
+    *end_pos = 32;

[Pawel Osciak, 2012/07/22 15:08:17]

Do you think you should be sending the IVF header to the decoder? Perhaps that's
why it's not working now?

[Ami GONE FROM CHROMIUM, 2012/07/22 23:18:29]

Merely omitting the 32-byte header doesn't change the symptoms of failure I'm
seeing (plus, that header specifies height/width, so I'd be shocked if that
worked).
Omitting the 12-byte per-frame header as well triggers other problems.

It'd be best to get a description of the expectations around the stream from the
mfr.

+  for (int i = 0; i < num_fragments_per_decode_; ++i) {
+    uint32 frame_size = *reinterpret_cast<uint32*>(&encoded_data_[*end_pos]);

[Pawel Osciak, 2012/07/22 15:08:17]

I'm assuming you are ok segfaulting here on erroneous streams.

[Ami GONE FROM CHROMIUM, 2012/07/22 23:18:29]

Yes, being a test binary I'm fine with that.

+    *end_pos += 12;  // Skip frame header.
+    *end_pos += frame_size;
+    if (*end_pos + 12 >= encoded_data_.size())
+      return;
+  }
+}
+
+void GLRenderingVDAClient::DecodeNextFragments() {
   if (decoder_deleted())
     return;
   if (encoded_data_next_pos_to_decode_ == encoded_data_.size()) {
     if (outstanding_decodes_ == 0) {
       decoder_->Flush();
       SetState(CS_FLUSHING);
     }
     return;
   }
   size_t start_pos = encoded_data_next_pos_to_decode_;
   size_t end_pos;
-  GetRangeForNextNALUs(start_pos, &end_pos);
+  GetRangeForNextFragments(start_pos, &end_pos);
 
-  // Populate the shared memory buffer w/ the NALU, duplicate its handle, and
-  // hand it off to the decoder.
+  // Populate the shared memory buffer w/ the fragments, duplicate its handle,
+  // and hand it off to the decoder.
   base::SharedMemory shm;
   CHECK(shm.CreateAndMapAnonymous(end_pos - start_pos))
       << start_pos << ", " << end_pos;
   memcpy(shm.memory(), encoded_data_.data() + start_pos, end_pos - start_pos);
   base::SharedMemoryHandle dup_handle;
   CHECK(shm.ShareToProcess(base::Process::Current().handle(), &dup_handle));
   media::BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_++, dup_handle, end_pos - start_pos);
   decoder_->Decode(bitstream_buffer);
   ++outstanding_decodes_;
   encoded_data_next_pos_to_decode_ = end_pos;
 
   if (!remaining_play_throughs_ &&
       -delete_decoder_state_ == next_bitstream_buffer_id_) {
     DeleteDecoder();
   }
 }
 
 double GLRenderingVDAClient::frames_per_second() {
   base::TimeDelta delta = last_frame_delivered_ticks_ - initialize_done_ticks_;
   if (delta.InSecondsF() == 0)
     return 0;
   return num_decoded_frames_ / delta.InSecondsF();
 }
 
 // Test parameters:
-// - Number of NALUs per Decode() call.
+// - Number of fragments per Decode() call.
 // - Number of concurrent decoders.
 // - 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.
 class VideoDecodeAcceleratorTest
     : public ::testing::TestWithParam<
   Tuple6<int, int, int, int, ResetPoint, ClientState> > {
 };
 
@@ skipping 29 matching lines @@
 
 // Test the most straightforward case possible: data is decoded from a single
 // chunk and rendered to the screen.
 TEST_P(VideoDecodeAcceleratorTest, TestSimpleDecode) {
   // Can be useful for debugging VLOGs from OVDA.
   // logging::SetMinLogLevel(-1);
 
   // Required for Thread to work.  Not used otherwise.
   base::ShadowingAtExitManager at_exit_manager;
 
-  const int num_NALUs_per_decode = GetParam().a;
+  const int num_fragments_per_decode = GetParam().a;
   const size_t num_concurrent_decoders = GetParam().b;
   const size_t num_in_flight_decodes = GetParam().c;
   const int num_play_throughs = GetParam().d;
   const int reset_after_frame_num = GetParam().e;
   const int delete_decoder_state = GetParam().f;
 
   FilePath::StringType test_video_file;
   int frame_width, frame_height;
-  int num_frames, num_NALUs, min_fps_render, min_fps_no_render, profile;
+  int num_frames, num_fragments, min_fps_render, min_fps_no_render, profile;
   ParseTestVideoData(test_video_data, &test_video_file, &frame_width,
-                     &frame_height, &num_frames, &num_NALUs,
+                     &frame_height, &num_frames, &num_fragments,
                      &min_fps_render, &min_fps_no_render, &profile);
   min_fps_render /= num_concurrent_decoders;
   min_fps_no_render /= num_concurrent_decoders;
 
   // If we reset mid-stream and start playback over, account for frames that are
   // decoded twice in our expectations.
   if (num_frames > 0 && reset_after_frame_num >= 0)
     num_frames += reset_after_frame_num;
 
   // Suppress GL swapping in all but a few tests, to cut down overall test
   // runtime.
-  const bool suppress_swap_to_display = num_NALUs_per_decode > 1;
+  const bool suppress_swap_to_display = num_fragments_per_decode > 1;
 
   std::vector<ClientStateNotification*> notes(num_concurrent_decoders, NULL);
   std::vector<GLRenderingVDAClient*> clients(num_concurrent_decoders, NULL);
 
   // Read in the video data.
   std::string data_str;
   CHECK(file_util::ReadFileToString(FilePath(test_video_file), &data_str))
       << "test_video_file: " << FilePath(test_video_file).MaybeAsASCII();
 
   // Initialize the rendering helper.
@@ skipping 16 matching lines @@
                  base::Unretained(rendering_helper.get()),
                  suppress_swap_to_display, num_concurrent_decoders,
                  frame_width, frame_height, &done));
   done.Wait();
 
   // First kick off all the decoders.
   for (size_t index = 0; index < num_concurrent_decoders; ++index) {
     ClientStateNotification* note = new ClientStateNotification();
     notes[index] = note;
     GLRenderingVDAClient* client = new GLRenderingVDAClient(
-        rendering_helper.get(), index, note, data_str, num_NALUs_per_decode,
+        rendering_helper.get(), index, note, data_str, num_fragments_per_decode,
         num_in_flight_decodes, num_play_throughs, reset_after_frame_num,
         delete_decoder_state, frame_width, frame_height, profile);
     clients[index] = client;
 
     rendering_thread.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&GLRenderingVDAClient::CreateDecoder,
                    base::Unretained(client)));
 
     ASSERT_EQ(note->Wait(), CS_DECODER_SET);
@@ skipping 40 matching lines @@
   // Finally assert that decoding went as expected.
   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];
     if (num_frames > 0)
       EXPECT_EQ(client->num_decoded_frames(), num_frames);
-    if (num_NALUs > 0 && reset_after_frame_num < 0) {
+    if (num_fragments > 0 && reset_after_frame_num < 0) {
       EXPECT_EQ(client->num_done_bitstream_buffers(),
-                ceil(static_cast<double>(num_NALUs) / num_NALUs_per_decode));
+                ceil(static_cast<double>(num_fragments) /
+                     num_fragments_per_decode));
     }
     LOG(INFO) << "Decoder " << i << " fps: " << client->frames_per_second();
     int min_fps = suppress_swap_to_display ? min_fps_no_render : min_fps_render;
     if (min_fps > 0)
       EXPECT_GT(client->frames_per_second(), min_fps);
   }
 
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&STLDeleteElements<std::vector<GLRenderingVDAClient*> >,
@@ skipping 36 matching lines @@
         MakeTuple(1, 1, 1, 1, END_OF_STREAM_RESET, CS_RESETTING),
         MakeTuple(1, 1, 1, 1, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(1, 1, 1, 1, END_OF_STREAM_RESET,
                   static_cast<ClientState>(-1)),
         MakeTuple(1, 1, 1, 1, END_OF_STREAM_RESET,
                   static_cast<ClientState>(-10)),
         MakeTuple(1, 1, 1, 1, END_OF_STREAM_RESET,
                   static_cast<ClientState>(-100))));
 
 // Test that decoding various variation works: multiple concurrent decoders and
-// multiple NALUs per Decode() call.
+// multiple fragments per Decode() call.
 INSTANTIATE_TEST_CASE_P(
     DecodeVariations, VideoDecodeAcceleratorTest,
     ::testing::Values(
         MakeTuple(1, 1, 1, 1, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(1, 1, 10, 1, END_OF_STREAM_RESET, CS_RESET),
         // Tests queuing.
         MakeTuple(1, 1, 15, 1, END_OF_STREAM_RESET, CS_RESET),
         // +0 hack below to promote enum to int.
         MakeTuple(1, kMinSupportedNumConcurrentDecoders + 0, 1, 1,
                   END_OF_STREAM_RESET, CS_RESET),
@@ skipping 57 matching lines @@
 
   base::ShadowingAtExitManager at_exit_manager;
   RenderingHelper::InitializePlatform();
 
 #if defined(OS_WIN)
   DXVAVideoDecodeAccelerator::PreSandboxInitialization();
 #endif
 
   return RUN_ALL_TESTS();
 }