Revert hardware decoder changes causing ChromeOS HW test crash.

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 60 matching lines @@
 namespace {
 
 // 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.
+// - |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.
-// - |numfragments| NALU (h264) or frame (VP8/9) count 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::VideoCodecProfile set during Initialization.
 // An empty value for a numeric field means "ignore".
 const base::FilePath::CharType* g_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");
 
 // The file path of the test output log. This is used to communicate the test
@@ skipping 197 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.
+      size_t start_pos, size_t* end_pos);  // For VP8.
 
   // 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 362 matching lines @@
     *end_pos = start_pos;
     while (*end_pos + 4 < encoded_data_.size()) {
       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);
+  DCHECK_LE(profile_, media::VP8PROFILE_MAX);
   return GetBytesForNextFragment(start_pos, 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);
+  DCHECK_LE(profile_, media::VP8PROFILE_MAX);
   return GetBytesForNextFrame(start_pos, 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;
   CHECK(LookingAtNAL(encoded_data_, start_pos));
   *end_pos += 4;
@@ skipping 28 matching lines @@
     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;
   } else if (profile >= media::VP8PROFILE_MIN &&
-             profile <= media::VP9PROFILE_MAX) {
+             profile <= media::VP8PROFILE_MAX) {
     return (size > 0 && !(data[0] & 0x01));
   }
   // Shouldn't happen at this point.
   LOG(FATAL) << "Invalid profile: " << profile;
   return false;
 }
 
 void GLRenderingVDAClient::DecodeNextFragment() {
   if (decoder_deleted())
     return;
@@ skipping 713 matching lines @@
     if (it->first == "ozone-platform" || it->first == "ozone-use-surfaceless")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
   content::RenderingHelper::InitializeOneOff();
 
   return RUN_ALL_TESTS();
 }