media: Support better decoder switching

media/filters/video_frame_stream_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.
 
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/fake_demuxer_stream.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_filters.h"
@@ skipping 47 matching lines @@
                                               kNumBuffersInOneConfig,
                                               GetParam().is_encrypted)),
         is_initialized_(false),
         num_decoded_frames_(0),
         pending_initialize_(false),
         pending_read_(false),
         pending_reset_(false),
         pending_stop_(false),
         num_decoded_bytes_unreported_(0),
         has_no_key_(false) {
-    int decoding_delay = GetParam().decoding_delay;
-    int parallel_decoding = GetParam().parallel_decoding;
-    BytesDecodedCB bytes_decoded_cb = base::Bind(
-        &VideoFrameStreamTest::OnBytesDecoded, base::Unretained(this));
-
-    // Provide 3 decoders to test fallback cases.
-    // TODO(xhwang): We should test the case where only certain decoder
-    // supports encrypted streams. Currently this is hard to test because we use
-    // parameterized tests which need to pass in all combinations.
-    ScopedVector<VideoDecoder> decoders;
-    for (int i = 0; i < 3; ++i) {
-      FakeVideoDecoder* decoder =
-          new FakeVideoDecoder(GetDecoderName(i), decoding_delay,
-                               parallel_decoding, bytes_decoded_cb);
-
-      if (GetParam().is_encrypted && !GetParam().has_decryptor)
-        decoder->EnableEncryptedConfigSupport();
-
-      decoders.push_back(decoder);
-
-      // Keep a copy of the raw pointers so we can change the behavior of each
-      // decoder.
-      decoders_.push_back(decoder);
-    }
-
     video_frame_stream_.reset(new VideoFrameStream(
-        message_loop_.task_runner(), std::move(decoders), &media_log_));
-
+        message_loop_.task_runner(),
+        base::Bind(&VideoFrameStreamTest::CreateVideoDecodersForTest,
+                   base::Unretained(this)),
+        &media_log_));
     video_frame_stream_->set_decoder_change_observer_for_testing(base::Bind(
         &VideoFrameStreamTest::OnDecoderChanged, base::Unretained(this)));
 
     if (GetParam().is_encrypted && GetParam().has_decryptor) {
       decryptor_.reset(new NiceMock<MockDecryptor>());
 
       // Decryptor can only decrypt (not decrypt-and-decode) so that
       // DecryptingDemuxerStream will be used.
       EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
           .WillRepeatedly(RunCallback<1>(false));
@@ skipping 17 matching lines @@
     decoders_.clear();
     video_frame_stream_.reset();
     base::RunLoop().RunUntilIdle();
 
     DCHECK(!pending_initialize_);
     DCHECK(!pending_read_);
     DCHECK(!pending_reset_);
     DCHECK(!pending_stop_);
   }
 
+  void OnBytesDecoded(int count) {
+    num_decoded_bytes_unreported_ += count;
+  }
+
+  // Callback to create a list of decoders for the DecoderSelector to select
+  // from. Decoder selection happens
+  // - on the initial selection in Initialize(),
+  // - on decoder reinitialization failure, which can be simulated by calling
+  //   decoder_->SimulateFailureToInit(), and
+  // - on decode error of the first buffer, which can be simulated by calling
+  //   decoder_->SimulateError() before reading the first frame.
+  ScopedVector<VideoDecoder> CreateVideoDecodersForTest() {
+    // Previously decoders could have been destroyed on decoder reselection.
+    decoders_.clear();
+
+    // Provide 3 decoders to test fallback cases.
+    // TODO(xhwang): We should test the case where only certain decoder
+    // supports encrypted streams. Currently this is hard to test because we use
+    // parameterized tests which need to pass in all combinations.
+    ScopedVector<VideoDecoder> decoders;
+    for (int i = 0; i < 3; ++i) {
+      FakeVideoDecoder* decoder =
+          new FakeVideoDecoder(GetDecoderName(i), GetParam().decoding_delay,
+                               GetParam().parallel_decoding,
+                               base::Bind(&VideoFrameStreamTest::OnBytesDecoded,
+                                          base::Unretained(this)));
+
+      if (GetParam().is_encrypted && !GetParam().has_decryptor)
+        decoder->EnableEncryptedConfigSupport();
+
+      decoders.push_back(decoder);
+
+      // Keep a copy of the raw pointers so we can change the behavior of each
+      // decoder.
+      decoders_.push_back(decoder);
+    }
+
+    for (const auto& i : decoder_indices_to_fail_init_)
+      decoders_[i]->SimulateFailureToInit();
+
+    for (const auto& i : decoder_indices_to_hold_init_)
+      decoders_[i]->HoldNextInit();
+
+    for (const auto& i : decoder_indices_to_hold_decode_)
+      decoders_[i]->HoldDecode();
+
+    decoder_indices_to_fail_init_.clear();
+    decoder_indices_to_hold_init_.clear();
+    decoder_indices_to_hold_decode_.clear();
+
+    return decoders;
+  }
+
+  // On next decoder selection, fail initialization on decoders specified by
+  // |decoder_indices|.
+  void FailDecoderInitOnSelection(const std::vector<int>& decoder_indices) {
+    decoder_indices_to_fail_init_ = decoder_indices;
+  }
+
+  // On next decoder selection, hold initialization on decoders specified by
+  // |decoder_indices|.
+  void HoldDecoderInitOnSelection(const std::vector<int>& decoder_indices) {
+    decoder_indices_to_hold_init_ = decoder_indices;
+  }
+
+  // After next decoder selection, hold decode on decoders specified by
+  // |decoder_indices|. This is needed because after decoder selection decode
+  // may be resumed immediately and it'll be too late to hold decode then.
+  void HoldDecodeAfterSelection(const std::vector<int>& decoder_indices) {
+    decoder_indices_to_hold_decode_ = decoder_indices;
+  }
+
+  // Updates the |decoder_| currently being used by VideoFrameStream.
+  void OnDecoderChanged(VideoDecoder* decoder) {
+    if (!decoder) {
+      decoder_ = nullptr;
+      return;
+    }
+
+    std::string name = decoder->GetDisplayName();
+    ASSERT_TRUE(GetDecoderName(0) == name || GetDecoderName(1) == name ||
+                GetDecoderName(2) == name);
+    decoder_ = static_cast<FakeVideoDecoder*>(decoder);
+  }
+
   MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
 
   void OnStatistics(const PipelineStatistics& statistics) {
     num_decoded_bytes_unreported_ -= statistics.video_bytes_decoded;
   }
 
-  void OnBytesDecoded(int count) {
-    num_decoded_bytes_unreported_ += count;
-  }
-
-  void SimulateDecoderInitFailure(const std::vector<int>& decoder_indices) {
-    for (const auto& i : decoder_indices)
-      decoders_[i]->SimulateFailureToInit();
-  }
-
   void OnInitialized(bool success) {
     DCHECK(!pending_read_);
     DCHECK(!pending_reset_);
     DCHECK(pending_initialize_);
     pending_initialize_ = false;
 
     is_initialized_ = success;
     if (!success)
       decoders_.clear();
   }
 
   void Initialize() {
     pending_initialize_ = true;
     video_frame_stream_->Initialize(
         demuxer_stream_.get(), base::Bind(&VideoFrameStreamTest::OnInitialized,
                                           base::Unretained(this)),
         cdm_context_.get(),
         base::Bind(&VideoFrameStreamTest::OnStatistics, base::Unretained(this)),
         base::Bind(&VideoFrameStreamTest::OnWaitingForDecryptionKey,
                    base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
-  void OnDecoderChanged(VideoDecoder* decoder) {
-    if (!decoder) {
-      decoder_ = nullptr;
-      return;
-    }
-
-    std::string name = decoder->GetDisplayName();
-    ASSERT_TRUE(GetDecoderName(0) == name || GetDecoderName(1) == name ||
-                GetDecoderName(2) == name);
-    decoder_ = static_cast<FakeVideoDecoder*>(decoder);
-  }
-
   // Fake Decrypt() function used by DecryptingDemuxerStream. It does nothing
   // but removes the DecryptConfig to make the buffer unencrypted.
   void Decrypt(Decryptor::StreamType stream_type,
                const scoped_refptr<DecoderBuffer>& encrypted,
                const Decryptor::DecryptCB& decrypt_cb) {
     DCHECK(encrypted->decrypt_config());
     if (has_no_key_) {
       decrypt_cb.Run(Decryptor::kNoKey, NULL);
       return;
     }
@@ skipping 169 matching lines @@
 
   // Use NiceMock since we don't care about most of calls on the decryptor,
   // e.g. RegisterNewKeyCB().
   std::unique_ptr<NiceMock<MockDecryptor>> decryptor_;
 
   // Raw pointers to the list of decoders to be select from by DecoderSelector.
   // Three decoders are needed to test that decoder fallback can occur more than
   // once on a config change. They are owned by |video_frame_stream_|.
   std::vector<FakeVideoDecoder*> decoders_;
 
+  std::vector<int> decoder_indices_to_fail_init_;
+  std::vector<int> decoder_indices_to_hold_init_;
+  std::vector<int> decoder_indices_to_hold_decode_;
+
   // The current decoder used by |video_frame_stream_|.
   FakeVideoDecoder* decoder_;
 
   bool is_initialized_;
   int num_decoded_frames_;
   bool pending_initialize_;
   bool pending_read_;
   bool pending_reset_;
   bool pending_stop_;
   int num_decoded_bytes_unreported_;
@@ skipping 29 matching lines @@
     VideoFrameStreamTest,
     ::testing::Values(VideoFrameStreamTestParams(false, false, 0, 3),
                       VideoFrameStreamTestParams(false, false, 2, 3)));
 
 TEST_P(VideoFrameStreamTest, Initialization) {
   Initialize();
   EXPECT_TRUE(is_initialized_);
 }
 
 TEST_P(VideoFrameStreamTest, AllDecoderInitializationFails) {
-  SimulateDecoderInitFailure({0, 1, 2});
+  FailDecoderInitOnSelection({0, 1, 2});
   Initialize();
   EXPECT_FALSE(is_initialized_);
 }
 
 TEST_P(VideoFrameStreamTest, PartialDecoderInitializationFails) {
-  SimulateDecoderInitFailure({0, 1});
+  FailDecoderInitOnSelection({0, 1});
   Initialize();
   EXPECT_TRUE(is_initialized_);
 }
 
 TEST_P(VideoFrameStreamTest, ReadOneFrame) {
   Initialize();
   Read();
 }
 
 TEST_P(VideoFrameStreamTest, ReadAllFrames) {
@@ skipping 210 matching lines @@
   Reset();
 }
 
 // In the following Destroy_* tests, |video_frame_stream_| is destroyed in
 // VideoFrameStreamTest dtor.
 
 TEST_P(VideoFrameStreamTest, Destroy_BeforeInitialization) {
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_DuringInitialization) {
-  decoders_[0]->HoldNextInit();
+  HoldDecoderInitOnSelection({0});
   Initialize();
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_AfterInitialization) {
   Initialize();
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_DuringReinitialization) {
   Initialize();
   EnterPendingState(DECODER_REINIT);
@@ skipping 63 matching lines @@
   EnterPendingState(DECODER_RESET);
   SatisfyPendingCallback(DECODER_DECODE);
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_AfterRead_AfterReset) {
   Initialize();
   Read();
   Reset();
 }
 
-// The following tests cover the fallback logic.
+// The following tests cover the fallback logic after reinitialization error or
+// decode error of the first buffer after initialization.
 
-TEST_P(VideoFrameStreamTest, FallbackDecoder_SelectedOnInitialDecodeError) {
+TEST_P(VideoFrameStreamTest, FallbackDecoder_DecodeError) {
   Initialize();
   decoder_->SimulateError();
   ReadOneFrame();
 
   // |video_frame_stream_| should have fallen back to a new decoder.
   ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
+
   ASSERT_FALSE(pending_read_);
   ASSERT_EQ(VideoFrameStream::OK, last_read_status_);
 
   // Check that we fallbacked to Decoder2.
   ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 
   // Verify no frame was dropped.
   ReadAllFrames();
 }
 
@@ skipping 51 matching lines @@
   // Queue one read, defer the second.
   frame_read_ = nullptr;
   pending_read_ = true;
   video_frame_stream_->Read(
       base::Bind(&VideoFrameStreamTest::FrameReady, base::Unretained(this)));
   demuxer_stream_->HoldNextRead();
 
   // Force an error to occur on the first decode, but ensure it isn't propagated
   // until after the next read has been started.
   decoder_->SimulateError();
-  decoders_[1]->HoldDecode();
+  HoldDecodeAfterSelection({1});
 
   // Complete the fallback to the second decoder with the read still pending.
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
 
   // Can't check the original decoder right now, it might have been destroyed
   // already. Verify that there was nothing decoded until we kicked the decoder.
   EXPECT_EQ(decoder_->total_bytes_decoded(), 0);
   decoder_->SatisfyDecode();
   const int first_decoded_bytes = decoder_->total_bytes_decoded();
   ASSERT_GT(first_decoded_bytes, 0);
 
   // Satisfy the previously pending read and ensure it is decoded.
   demuxer_stream_->SatisfyRead();
   base::RunLoop().RunUntilIdle();
   ASSERT_GT(decoder_->total_bytes_decoded(), first_decoded_bytes);
 }
 
-TEST_P(VideoFrameStreamTest,
-       FallbackDecoder_SelectedOnInitialDecodeError_Twice) {
+TEST_P(VideoFrameStreamTest, FallbackDecoder_DecodeErrorTwice) {
   Initialize();
+
+  // Simulate decode error to trigger the fallback path.
   decoder_->SimulateError();
 
-  decoders_[1]->HoldNextInit();
+  // Decoder 0 should be blacklisted and never tried. Hold decode on decoder 1
+  // and simulate decode error again.
+  HoldDecodeAfterSelection({1});
   ReadOneFrame();
-
-  decoders_[1]->SatisfyInit();
-  decoders_[1]->SimulateError();
+  ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
+  decoder_->SimulateError();
+  decoder_->SatisfyDecode();
   base::RunLoop().RunUntilIdle();
 
-  ASSERT_EQ(GetDecoderName(2), decoder_->GetDisplayName());
+  // Only one fallback is allowed so we are not falling back to other decoders.
+  ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
+  EXPECT_FALSE(pending_read_);
+  ASSERT_EQ(VideoFrameStream::DECODE_ERROR, last_read_status_);
+}
 
-  // |video_frame_stream_| should have fallen back to |decoders_[2]|.
-  ASSERT_FALSE(pending_read_);
-  ASSERT_EQ(VideoFrameStream::OK, last_read_status_);
+TEST_P(VideoFrameStreamTest,
+       FallbackDecoder_DecodeErrorTwice_AfterReinitialization) {
+  Initialize();
 
-  // Can't check previously selected decoder(s) right now, they might have been
-  // destroyed already.
-  ASSERT_GT(decoder_->total_bytes_decoded(), 0);
+  // Simulate decode error to trigger the fallback path.
+  decoder_->SimulateError();
+  ReadOneFrame();
+  ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
 
-  // Verify no frame was dropped.
-  ReadAllFrames();
+  // Simulate reinitialize error of decoder 1.
+  decoder_->SimulateFailureToInit();
+
+  // Decoder 0 should be selected again. Simulate immediate decode error after
+  // reinitialization.
+  HoldDecodeAfterSelection({0});
+  ReadUntilDecoderReinitialized();
+  ASSERT_EQ(GetDecoderName(0), decoder_->GetDisplayName());
+  decoder_->SimulateError();
+  decoder_->SatisfyDecode();
+  base::RunLoop().RunUntilIdle();
+
+  // VideoDecoderStream has produced video frames, so we are not trying fallback
+  // again.
+  // TODO(xhwang): Revisit this behavior, e.g. always try to fallback if a newly
+  // selected decoder has not produced any video frames before.
+  ASSERT_EQ(GetDecoderName(0), decoder_->GetDisplayName());
+  EXPECT_FALSE(pending_read_);
+  ASSERT_EQ(VideoFrameStream::DECODE_ERROR, last_read_status_);
 }
 
 TEST_P(VideoFrameStreamTest, FallbackDecoder_ConfigChangeClearsPendingBuffers) {
   // Test case is only interesting if the decoder can receive a config change
   // before returning its first frame.
   if (GetParam().decoding_delay < kNumBuffersInOneConfig)
     return;
 
   Initialize();
   EnterPendingState(DEMUXER_READ_CONFIG_CHANGE);
@@ skipping 37 matching lines @@
 TEST_P(VideoFrameStreamTest, FallbackDecoder_PendingBuffersIsFilledAndCleared) {
   // Test applies only when there is a decoder delay, and the decoder will not
   // receive a config change before outputing its first frame. Parallel decoding
   // is also disabled in this test case, for readability and simplicity of the
   // unit test.
   if (GetParam().decoding_delay == 0 ||
       GetParam().decoding_delay > kNumBuffersInOneConfig ||
       GetParam().parallel_decoding > 1) {
     return;
   }
+
   Initialize();
 
   // Block on demuxer read and decoder decode so we can step through.
   demuxer_stream_->HoldNextRead();
   decoder_->HoldDecode();
   ReadOneFrame();
 
   int demuxer_reads_satisfied = 0;
   // Send back and requests buffers until the next one would fill the decoder
   // delay.
@@ skipping 11 matching lines @@
               video_frame_stream_->get_pending_buffers_size_for_testing());
     // No fallback buffers should be queued up yet.
     EXPECT_EQ(0, video_frame_stream_->get_fallback_buffers_size_for_testing());
   }
 
   // Hold the init before triggering the error, to verify internal state.
   demuxer_stream_->SatisfyReadAndHoldNext();
   ++demuxer_reads_satisfied;
 
   decoder_->SimulateError();
-  decoders_[1]->HoldNextInit();
+
+  HoldDecoderInitOnSelection({1});
+  HoldDecodeAfterSelection({1});
+
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(pending_read_);
   EXPECT_EQ(demuxer_reads_satisfied,
             video_frame_stream_->get_pending_buffers_size_for_testing());
 
   decoders_[1]->SatisfyInit();
-  decoders_[1]->HoldDecode();
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
 
   // Make sure the pending buffers have been transfered to fallback buffers.
   // One call to Decode() during the initialization process, so we expect one
   // buffer to already have been consumed from the fallback buffers.
   // Pending buffers should never go down (unless we encounter a config change)
   EXPECT_EQ(demuxer_reads_satisfied - 1,
             video_frame_stream_->get_fallback_buffers_size_for_testing());
   EXPECT_EQ(demuxer_reads_satisfied,
             video_frame_stream_->get_pending_buffers_size_for_testing());
 
   decoder_->SatisfyDecode();
   base::RunLoop().RunUntilIdle();
 
-  // Make sure all buffers consumed by |decoders_[1]| have come from the
-  // fallback. Pending buffers should not have been cleared yet.
+  // Make sure all buffers consumed by |decoders_| have come from the fallback.
+  // Pending buffers should not have been cleared yet.
   EXPECT_EQ(0, video_frame_stream_->get_fallback_buffers_size_for_testing());
   EXPECT_EQ(demuxer_reads_satisfied,
             video_frame_stream_->get_pending_buffers_size_for_testing());
   EXPECT_TRUE(pending_read_);
 
   // Give the decoder one more buffer, enough to release a frame.
   demuxer_stream_->SatisfyReadAndHoldNext();
   base::RunLoop().RunUntilIdle();
 
   // New buffers should not have been added after the frame was released.
   EXPECT_EQ(video_frame_stream_->get_pending_buffers_size_for_testing(), 0);
   EXPECT_FALSE(pending_read_);
 
   demuxer_stream_->SatisfyRead();
 
   // Confirm no frames were dropped.
   ReadAllFrames();
 }
 
 TEST_P(VideoFrameStreamTest, FallbackDecoder_SelectedOnDecodeThenInitErrors) {
   Initialize();
   decoder_->SimulateError();
-  SimulateDecoderInitFailure({1});
+  FailDecoderInitOnSelection({1});
   ReadOneFrame();
 
+  // Decoder 0 should be blacklisted, and decoder 1 fails to initialize, so
+  // |video_frame_stream_| should have fallen back to decoder 2.
   ASSERT_EQ(GetDecoderName(2), decoder_->GetDisplayName());
 
-  // |video_frame_stream_| should have fallen back to |decoders_[2]|
   ASSERT_FALSE(pending_read_);
   ASSERT_EQ(VideoFrameStream::OK, last_read_status_);
 
   // Can't check previously selected decoder(s) right now, they might have been
   // destroyed already.
   ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 
   // Verify no frame was dropped.
   ReadAllFrames();
 }
 
 TEST_P(VideoFrameStreamTest, FallbackDecoder_SelectedOnInitThenDecodeErrors) {
-  SimulateDecoderInitFailure({0});
+  FailDecoderInitOnSelection({0});
   Initialize();
   ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
 
   decoder_->HoldDecode();
   ReadOneFrame();
   decoder_->SimulateError();
   base::RunLoop().RunUntilIdle();
 
-  // |video_frame_stream_| should have fallen back to |decoders_[2]|
-  ASSERT_EQ(GetDecoderName(2), decoder_->GetDisplayName());
+  // |video_frame_stream_| should have fallen back to decoder 0.
+  ASSERT_EQ(GetDecoderName(0), decoder_->GetDisplayName());
 
   ASSERT_FALSE(pending_read_);
   ASSERT_EQ(VideoFrameStream::OK, last_read_status_);
 
   // Can't check previously selected decoder(s) right now, they might have been
   // destroyed already.
   ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 
   // Verify no frame was dropped.
   ReadAllFrames();
@@ skipping 40 matching lines @@
 
   // The error must surface from Read() as DECODE_ERROR.
   while (last_read_status_ == VideoFrameStream::OK) {
     ReadOneFrame();
     base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(pending_read_);
   }
   EXPECT_EQ(VideoFrameStream::DECODE_ERROR, last_read_status_);
 }
 
-TEST_P(VideoFrameStreamTest, FallbackDecoderSelectedOnFailureToReinitialize) {
+TEST_P(VideoFrameStreamTest, ReinitializeFailure_Once) {
   Initialize();
   decoder_->SimulateFailureToInit();
   ReadUntilDecoderReinitialized();
   ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
   ReadAllFrames();
   ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 }
 
-TEST_P(VideoFrameStreamTest,
-       FallbackDecoderSelectedOnFailureToReinitialize_Twice) {
+TEST_P(VideoFrameStreamTest, ReinitializeFailure_Twice) {
   Initialize();
+
+  // Trigger reinitialization error, and fallback to decoder 1.
   decoder_->SimulateFailureToInit();
   ReadUntilDecoderReinitialized();
   ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
+
   ReadOneFrame();
+
+  // Trigger reinitialization error again, and fallback back to decoder 0.
   decoder_->SimulateFailureToInit();
   ReadUntilDecoderReinitialized();
-  ASSERT_EQ(GetDecoderName(2), decoder_->GetDisplayName());
+  ASSERT_EQ(GetDecoderName(0), decoder_->GetDisplayName());
   ReadAllFrames();
 }
 
-TEST_P(VideoFrameStreamTest, DecodeErrorAfterFallbackDecoderSelectionFails) {
+TEST_P(VideoFrameStreamTest, ReinitializeFailure_OneUnsupportedDecoder) {
   Initialize();
+
+  // The current decoder will fail to reinitialize and will be blacklisted.
   decoder_->SimulateFailureToInit();
-  SimulateDecoderInitFailure({1, 2});
+
+  // Decoder 1 will also fail to initialize on decoder selection.
+  FailDecoderInitOnSelection({1});
+
   ReadUntilDecoderReinitialized();
+
+  // As a result, decoder 2 will be selected.
+  ASSERT_EQ(GetDecoderName(2), decoder_->GetDisplayName());
+
+  ReadAllFrames();
+}
+
+TEST_P(VideoFrameStreamTest, ReinitializeFailure_NoSupportedDecoder) {
+  Initialize();
+
+  // The current decoder will fail to reinitialize and will be blacklisted.
+  decoder_->SimulateFailureToInit();
+
+  // Decoder 1 and 2 will also fail to initialize on decoder selection.
+  FailDecoderInitOnSelection({1, 2});
+
+  ReadUntilDecoderReinitialized();
+
   // The error will surface from Read() as DECODE_ERROR.
   while (last_read_status_ == VideoFrameStream::OK) {
     ReadOneFrame();
     base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(pending_read_);
   }
   EXPECT_EQ(VideoFrameStream::DECODE_ERROR, last_read_status_);
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_DuringFallbackDecoderSelection) {
   Initialize();
   decoder_->SimulateFailureToInit();
   EnterPendingState(DECODER_REINIT);
-  decoders_[1]->HoldNextInit();
+  HoldDecoderInitOnSelection({1});
   SatisfyPendingCallback(DECODER_REINIT);
 }
 
 }  // namespace media