Use the MediaCodec flush workaround in more cases

media/gpu/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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.
 
 #include "media/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 1257 matching lines @@
   // If there is already a reset in flight, then that counts.  This can really
   // only happen if somebody calls Reset.
   // If the surface is destroyed there's nothing to do.
   if (state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED)
     return;
 
   bitstream_buffers_in_decoder_.clear();
 
   if (pending_input_buf_index_ != -1) {
     // The data for that index exists in the input buffer, but corresponding
-    // shm block been deleted. Check that it is safe to flush the coec, i.e.
+    // shm block been deleted. Check that it is safe to flush the codec, i.e.
     // |pending_bitstream_records_| is empty.
     // TODO(timav): keep shm block for that buffer and remove this restriction.
     DCHECK(pending_bitstream_records_.empty());
     pending_input_buf_index_ = -1;
   }
 
   const bool did_codec_error_happen = state_ == ERROR;
   state_ = NO_ERROR;
 
   // Don't reset the codec here if there's no error and we're only flushing;
   // instead defer until the next decode call; this prevents us from unbacking
   // frames that might be out for display at end of stream.
   codec_needs_reset_ = false;
   if (drain_type_ == DRAIN_FOR_FLUSH && !did_codec_error_happen) {
     codec_needs_reset_ = true;
     return;
   }
 
   // We might increment error_sequence_token here to cancel any delayed errors,
   // but right now it's unclear that it's safe to do so.  If we are in an error
   // state because of a codec error, then it would be okay.  Otherwise, it's
   // less obvious that we are exiting the error state.  Since deferred errors
   // are only intended for fullscreen transitions right now, we take the more
   // conservative approach and let the errors post.
   // TODO(liberato): revisit this once we sort out the error state a bit more.
 
-  // When the codec is not in error state we can flush() for JB-MR2 and beyond.
-  // Prior to JB-MR2, flush() had several bugs (b/8125974, b/8347958) so we must
-  // delete the MediaCodec and create a new one. The full reconfigure is much
-  // slower and may cause visible freezing if done mid-stream.
+  // Flush the codec if possible, or create a new one if not.
   if (!did_codec_error_happen &&
-      base::android::BuildInfo::GetInstance()->sdk_int() >= 18) {
+      !media::MediaCodecUtil::CodecNeedsFlushWorkaround(media_codec_.get())) {
     DVLOG(3) << __FUNCTION__ << " Flushing MediaCodec.";
     media_codec_->Flush();
     // Since we just flushed all the output buffers, make sure that nothing is
     // using them.
     strategy_->CodecChanged(media_codec_.get());
   } else {
     DVLOG(3) << __FUNCTION__
              << " Deleting the MediaCodec and creating a new one.";
     g_avda_timer.Pointer()->StopTimer(this);
     ConfigureMediaCodecAsynchronously();
@@ skipping 454 matching lines @@
 
 bool AndroidVideoDecodeAccelerator::IsMediaCodecSoftwareDecodingForbidden()
     const {
   // Prevent MediaCodec from using its internal software decoders when we have
   // more secure and up to date versions in the renderer process.
   return !config_.is_encrypted && (codec_config_->codec_ == media::kCodecVP8 ||
                                    codec_config_->codec_ == media::kCodecVP9);
 }
 
 }  // namespace media