media: Refactor VideoFrameStreamTest

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 "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"
 #include "media/base/test_helpers.h"
 #include "media/base/timestamp_constants.h"
 #include "media/filters/decoder_stream.h"
 #include "media/filters/fake_video_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Assign;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
-static const int kNumConfigs = 4;
-static const int kNumBuffersInOneConfig = 5;
+namespace media {
 
-namespace media {
+const int kNumConfigs = 4;
+const int kNumBuffersInOneConfig = 5;
+
+static std::string GetDecoderName(int i) {
+  return std::string("VideoDecoder") + base::IntToString(i);
+}
 
 struct VideoFrameStreamTestParams {
   VideoFrameStreamTestParams(bool is_encrypted,
                              bool has_decryptor,
                              int decoding_delay,
                              int parallel_decoding)
       : is_encrypted(is_encrypted),
         has_decryptor(has_decryptor),
         decoding_delay(decoding_delay),
         parallel_decoding(parallel_decoding) {}
@@ skipping 18 matching lines @@
         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));
 
-    decoder1_ = new FakeVideoDecoder(decoding_delay, parallel_decoding,
-                                     bytes_decoded_cb);
-    decoder2_ = new FakeVideoDecoder(decoding_delay, parallel_decoding,
-                                     bytes_decoded_cb);
-    decoder3_ = new FakeVideoDecoder(decoding_delay, parallel_decoding,
-                                     bytes_decoded_cb);
-
+    // 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.
-    if (GetParam().is_encrypted && !GetParam().has_decryptor) {
-      decoder1_->EnableEncryptedConfigSupport();
-      decoder2_->EnableEncryptedConfigSupport();
-      decoder3_->EnableEncryptedConfigSupport();
+    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);
     }
 
-    ScopedVector<VideoDecoder> decoders;
-    decoders.push_back(decoder1_);
-    decoders.push_back(decoder2_);
-    decoders.push_back(decoder3_);
-
     video_frame_stream_.reset(new VideoFrameStream(
         message_loop_.task_runner(), std::move(decoders), &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));
       EXPECT_CALL(*decryptor_, Decrypt(_, _, _))
           .WillRepeatedly(Invoke(this, &VideoFrameStreamTest::Decrypt));
     }
 
     if (GetParam().is_encrypted) {
       cdm_context_.reset(new StrictMock<MockCdmContext>());
 
       EXPECT_CALL(*cdm_context_, GetDecryptor())
           .WillRepeatedly(Return(decryptor_.get()));
     }
   }
 
   ~VideoFrameStreamTest() {
     // Check that the pipeline statistics callback was fired correctly.
     EXPECT_EQ(num_decoded_bytes_unreported_, 0);
 
     is_initialized_ = false;
-    decoder1_ = NULL;
-    decoder2_ = NULL;
-    decoder3_ = NULL;
+    decoders_.clear();
     video_frame_stream_.reset();
     base::RunLoop().RunUntilIdle();
 
     DCHECK(!pending_initialize_);
     DCHECK(!pending_read_);
     DCHECK(!pending_reset_);
     DCHECK(!pending_stop_);
   }
 
   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) {
-      decoder1_ = NULL;
-      decoder2_ = NULL;
-      decoder3_ = NULL;
-    }
+    if (!success)
+      decoders_.clear();
   }
 
-  void InitializeVideoFrameStream() {
+  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 54 matching lines @@
   void ReadAllFrames() {
     // No frames should have been dropped.
     ReadAllFrames(kNumConfigs * kNumBuffersInOneConfig);
   }
 
   enum PendingState {
     NOT_PENDING,
     DEMUXER_READ_NORMAL,
     DEMUXER_READ_CONFIG_CHANGE,
     DECRYPTOR_NO_KEY,
-    DECODER_INIT,
     DECODER_REINIT,
     DECODER_DECODE,
     DECODER_RESET
   };
 
   void EnterPendingState(PendingState state) {
-    EnterPendingState(state, decoder1_);
-  }
-
-  void EnterPendingState(PendingState state, FakeVideoDecoder* decoder) {
     DCHECK_NE(state, NOT_PENDING);
     switch (state) {
       case DEMUXER_READ_NORMAL:
         demuxer_stream_->HoldNextRead();
         ReadUntilPending();
         break;
 
       case DEMUXER_READ_CONFIG_CHANGE:
         demuxer_stream_->HoldNextConfigChangeRead();
         ReadUntilPending();
         break;
 
       case DECRYPTOR_NO_KEY:
         if (GetParam().is_encrypted && GetParam().has_decryptor) {
           EXPECT_CALL(*this, OnWaitingForDecryptionKey());
           has_no_key_ = true;
         }
         ReadOneFrame();
         break;
 
-      case DECODER_INIT:
-        decoder->HoldNextInit();
-        InitializeVideoFrameStream();
-        break;
-
       case DECODER_REINIT:
-        decoder->HoldNextInit();
+        decoder_->HoldNextInit();
         ReadUntilPending();
         break;
 
       case DECODER_DECODE:
-        decoder->HoldDecode();
+        decoder_->HoldDecode();
         ReadUntilPending();
         break;
 
       case DECODER_RESET:
-        decoder->HoldNextReset();
+        decoder_->HoldNextReset();
         pending_reset_ = true;
         video_frame_stream_->Reset(base::Bind(&VideoFrameStreamTest::OnReset,
                                               base::Unretained(this)));
         base::RunLoop().RunUntilIdle();
         break;
 
       case NOT_PENDING:
         NOTREACHED();
         break;
     }
   }
 
   void SatisfyPendingCallback(PendingState state) {
-    SatisfyPendingCallback(state, decoder1_);
-  }
-
-  void SatisfyPendingCallback(PendingState state, FakeVideoDecoder* decoder) {
     DCHECK_NE(state, NOT_PENDING);
     switch (state) {
       case DEMUXER_READ_NORMAL:
       case DEMUXER_READ_CONFIG_CHANGE:
         demuxer_stream_->SatisfyRead();
         break;
 
       // This is only interesting to test during VideoFrameStream destruction.
       // There's no need to satisfy a callback.
       case DECRYPTOR_NO_KEY:
         NOTREACHED();
         break;
 
-      case DECODER_INIT:
-        decoder->SatisfyInit();
-        break;
-
       case DECODER_REINIT:
-        decoder->SatisfyInit();
+        decoder_->SatisfyInit();
         break;
 
       case DECODER_DECODE:
-        decoder->SatisfyDecode();
+        decoder_->SatisfyDecode();
         break;
 
       case DECODER_RESET:
-        decoder->SatisfyReset();
+        decoder_->SatisfyReset();
         break;
 
       case NOT_PENDING:
         NOTREACHED();
         break;
     }
 
     base::RunLoop().RunUntilIdle();
   }
 
-  void Initialize() {
-    EnterPendingState(DECODER_INIT);
-    SatisfyPendingCallback(DECODER_INIT);
-  }
-
   void Read() {
     EnterPendingState(DECODER_DECODE);
     SatisfyPendingCallback(DECODER_DECODE);
   }
 
   void Reset() {
     EnterPendingState(DECODER_RESET);
     SatisfyPendingCallback(DECODER_RESET);
   }
 
-  void ReadUntilDecoderReinitialized(FakeVideoDecoder* decoder) {
-    EnterPendingState(DECODER_REINIT, decoder);
-    SatisfyPendingCallback(DECODER_REINIT, decoder);
+  void ReadUntilDecoderReinitialized() {
+    EnterPendingState(DECODER_REINIT);
+    SatisfyPendingCallback(DECODER_REINIT);
   }
 
   base::MessageLoop message_loop_;
 
   MediaLog media_log_;
   std::unique_ptr<VideoFrameStream> video_frame_stream_;
   std::unique_ptr<FakeDemuxerStream> demuxer_stream_;
   std::unique_ptr<StrictMock<MockCdmContext>> cdm_context_;
 
   // 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_|.
-  FakeVideoDecoder* decoder1_;
-  FakeVideoDecoder* decoder2_;
-  FakeVideoDecoder* decoder3_;
+  std::vector<FakeVideoDecoder*> decoders_;
+
+  // 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_;
   scoped_refptr<VideoFrame> frame_read_;
   VideoFrameStream::Status last_read_status_;
@@ skipping 27 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) {
-  decoder1_->SimulateFailureToInit();
-  decoder2_->SimulateFailureToInit();
-  decoder3_->SimulateFailureToInit();
+  SimulateDecoderInitFailure({0, 1, 2});
   Initialize();
   EXPECT_FALSE(is_initialized_);
 }
 
 TEST_P(VideoFrameStreamTest, PartialDecoderInitializationFails) {
-  decoder1_->SimulateFailureToInit();
-  decoder2_->SimulateFailureToInit();
+  SimulateDecoderInitFailure({0, 1});
   Initialize();
   EXPECT_TRUE(is_initialized_);
 }
 
 TEST_P(VideoFrameStreamTest, ReadOneFrame) {
   Initialize();
   Read();
 }
 
 TEST_P(VideoFrameStreamTest, ReadAllFrames) {
@@ skipping 38 matching lines @@
   EXPECT_FALSE(pending_read_);
 }
 
 TEST_P(VideoFrameStreamTest, Read_BlockedDemuxerAndDecoder) {
   // Test applies only when the decoder allows multiple parallel requests.
   if (GetParam().parallel_decoding == 1)
     return;
 
   Initialize();
   demuxer_stream_->HoldNextRead();
-  decoder1_->HoldDecode();
+  decoder_->HoldDecode();
   ReadOneFrame();
   EXPECT_TRUE(pending_read_);
 
   int demuxed_buffers = 0;
 
   // Pass frames from the demuxer to the VideoFrameStream until the first read
   // request is satisfied, while always keeping one decode request pending.
   while (pending_read_) {
     ++demuxed_buffers;
     demuxer_stream_->SatisfyReadAndHoldNext();
     base::RunLoop().RunUntilIdle();
 
     // Always keep one decode request pending.
     if (demuxed_buffers > 1) {
-      decoder1_->SatisfySingleDecode();
+      decoder_->SatisfySingleDecode();
       base::RunLoop().RunUntilIdle();
     }
   }
 
   ReadUntilPending();
   EXPECT_TRUE(pending_read_);
 
   // Unblocking one decode request should unblock read even when demuxer is
   // still blocked.
-  decoder1_->SatisfySingleDecode();
+  decoder_->SatisfySingleDecode();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(pending_read_);
 
   // Stream should still be blocked on the demuxer after unblocking the decoder.
-  decoder1_->SatisfyDecode();
+  decoder_->SatisfyDecode();
   ReadUntilPending();
   EXPECT_TRUE(pending_read_);
 
   // Verify that the stream has returned all frames that have been demuxed,
   // accounting for the decoder delay.
   EXPECT_EQ(demuxed_buffers - GetParam().decoding_delay, num_decoded_frames_);
 
   // Unblocking the demuxer will unblock the stream.
   demuxer_stream_->SatisfyRead();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(pending_read_);
 }
 
 TEST_P(VideoFrameStreamTest, Read_DuringEndOfStreamDecode) {
   // Test applies only when the decoder allows multiple parallel requests, and
   // they are not satisfied in a single batch.
   if (GetParam().parallel_decoding == 1 || GetParam().decoding_delay != 0)
     return;
 
   Initialize();
-  decoder1_->HoldDecode();
+  decoder_->HoldDecode();
 
   // Read all of the frames up to end of stream. Since parallel decoding is
   // enabled, the end of stream buffer will be sent to the decoder immediately,
   // but we don't satisfy it yet.
   for (int configuration = 0; configuration < kNumConfigs; configuration++) {
     for (int frame = 0; frame < kNumBuffersInOneConfig; frame++) {
       ReadOneFrame();
       while (pending_read_) {
-        decoder1_->SatisfySingleDecode();
+        decoder_->SatisfySingleDecode();
         base::RunLoop().RunUntilIdle();
       }
     }
   }
 
   // Read() again. The callback must be delayed until the decode completes.
   ReadOneFrame();
   ASSERT_TRUE(pending_read_);
 
   // Satisfy decoding of the end of stream buffer. The read should complete.
-  decoder1_->SatisfySingleDecode();
+  decoder_->SatisfySingleDecode();
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(pending_read_);
   EXPECT_EQ(last_read_status_, VideoFrameStream::OK);
 
   // The read output should indicate end of stream.
   ASSERT_TRUE(frame_read_.get());
   EXPECT_TRUE(
       frame_read_->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM));
 }
 
@@ skipping 80 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) {
-  EnterPendingState(DECODER_INIT);
+  decoders_[0]->HoldNextInit();
+  Initialize();
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_AfterInitialization) {
   Initialize();
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_DuringReinitialization) {
   Initialize();
   EnterPendingState(DECODER_REINIT);
 }
@@ skipping 62 matching lines @@
   EnterPendingState(DECODER_RESET);
   SatisfyPendingCallback(DECODER_DECODE);
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_AfterRead_AfterReset) {
   Initialize();
   Read();
   Reset();
 }
 
+// The following tests cover the fallback logic.
+
 TEST_P(VideoFrameStreamTest, FallbackDecoder_SelectedOnInitialDecodeError) {
   Initialize();
-  decoder1_->SimulateError();
+  decoder_->SimulateError();
   ReadOneFrame();
 
-  // |video_frame_stream_| should have fallen back to |decoder2_|.
+  // |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_);
 
-  // Can't check |decoder1_| right now, it might have been destroyed already.
-  ASSERT_GT(decoder2_->total_bytes_decoded(), 0);
+  // Check that we fallbacked to Decoder2.
+  ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 
   // Verify no frame was dropped.
   ReadAllFrames();
 }
 
 TEST_P(VideoFrameStreamTest, FallbackDecoder_EndOfStreamReachedBeforeFallback) {
   // Only consider cases where there is a decoder delay. For test simplicity,
   // omit the parallel case.
   if (GetParam().decoding_delay == 0 || GetParam().parallel_decoding > 1)
     return;
 
   Initialize();
-  decoder1_->HoldDecode();
+  decoder_->HoldDecode();
   ReadOneFrame();
 
   // One buffer should have already pulled from the demuxer stream. Set the next
   // one to be an EOS.
   demuxer_stream_->SeekToEndOfStream();
 
-  decoder1_->SatisfySingleDecode();
+  decoder_->SatisfySingleDecode();
   base::RunLoop().RunUntilIdle();
 
   // |video_frame_stream_| should not have emited a frame.
   EXPECT_TRUE(pending_read_);
 
   // Pending buffers should contain a regular buffer and an EOS buffer.
   EXPECT_EQ(video_frame_stream_->get_pending_buffers_size_for_testing(), 2);
 
-  decoder1_->SimulateError();
+  decoder_->SimulateError();
   base::RunLoop().RunUntilIdle();
 
-  //  A frame should have been emited
+  ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
+
+  // A frame should have been emitted.
   EXPECT_FALSE(pending_read_);
   EXPECT_EQ(last_read_status_, VideoFrameStream::OK);
   EXPECT_FALSE(
       frame_read_->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM));
-  EXPECT_GT(decoder2_->total_bytes_decoded(), 0);
+  EXPECT_GT(decoder_->total_bytes_decoded(), 0);
 
   ReadOneFrame();
 
   EXPECT_FALSE(pending_read_);
   EXPECT_EQ(0, video_frame_stream_->get_fallback_buffers_size_for_testing());
   EXPECT_TRUE(
       frame_read_->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM));
 }
 
 TEST_P(VideoFrameStreamTest, FallbackDecoder_DoesReinitializeStompPendingRead) {
   // Test only the case where there is no decoding delay and parallel decoding.
   if (GetParam().decoding_delay != 0 || GetParam().parallel_decoding <= 1)
     return;
 
   Initialize();
-  decoder1_->HoldDecode();
+  decoder_->HoldDecode();
 
   // 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.
-  decoder1_->SimulateError();
-  decoder2_->HoldDecode();
+  decoder_->SimulateError();
+  decoders_[1]->HoldDecode();
 
   // Complete the fallback to the second decoder with the read still pending.
   base::RunLoop().RunUntilIdle();
 
-  // Can't check |decoder1_| right now, it might have been destroyed already.
-  // Verify that there was nothing decoded until we kicked the decoder.
-  EXPECT_EQ(decoder2_->total_bytes_decoded(), 0);
-  decoder2_->SatisfyDecode();
-  const int first_decoded_bytes = decoder2_->total_bytes_decoded();
+  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(decoder2_->total_bytes_decoded(), first_decoded_bytes);
+  ASSERT_GT(decoder_->total_bytes_decoded(), first_decoded_bytes);
 }
 
 TEST_P(VideoFrameStreamTest,
        FallbackDecoder_SelectedOnInitialDecodeError_Twice) {
   Initialize();
-  decoder1_->SimulateError();
-  decoder2_->HoldNextInit();
+  decoder_->SimulateError();
+
+  decoders_[1]->HoldNextInit();
   ReadOneFrame();
 
-  decoder2_->SatisfyInit();
-  decoder2_->SimulateError();
+  decoders_[1]->SatisfyInit();
+  decoders_[1]->SimulateError();
   base::RunLoop().RunUntilIdle();
 
-  // |video_frame_stream_| should have fallen back to |decoder3_|.
+  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 |decoder1_| or |decoder2_| right now, they might have been
+  // Can't check previously selected decoder(s) right now, they might have been
   // destroyed already.
-  ASSERT_GT(decoder3_->total_bytes_decoded(), 0);
+  ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 
   // Verify no frame was dropped.
   ReadAllFrames();
 }
 
 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;
@@ skipping 12 matching lines @@
 TEST_P(VideoFrameStreamTest, FallbackDecoder_ErrorDuringConfigChangeFlushing) {
   // 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);
   EXPECT_GT(video_frame_stream_->get_pending_buffers_size_for_testing(), 0);
 
-  decoder1_->HoldDecode();
+  decoder_->HoldDecode();
   SatisfyPendingCallback(DEMUXER_READ_CONFIG_CHANGE);
 
   // The flush request should have been sent and held.
   EXPECT_EQ(video_frame_stream_->get_pending_buffers_size_for_testing(), 0);
   EXPECT_TRUE(pending_read_);
 
-  // Triggering an error here will cause the frames in |decoder1_| to be lost.
-  // There are no pending buffers buffers to give to give to |decoder2_| due to
-  // crbug.com/603713.
-  decoder1_->SimulateError();
+  // Triggering an error here will cause the frames in selected decoder to be
+  // lost. There are no pending buffers to give to |decoders_[1]| due to
+  // http://crbug.com/603713
+  decoder_->SimulateError();
   base::RunLoop().RunUntilIdle();
 
-  // We want to make sure that |decoder2_| can decode the rest of the frames
+  // We want to make sure the fallback decoder can decode the rest of the frames
   // in the demuxer stream.
   ReadAllFrames(kNumBuffersInOneConfig * (kNumConfigs - 1));
 }
 
 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();
-  decoder1_->HoldDecode();
+  decoder_->HoldDecode();
   ReadOneFrame();
 
   int demuxer_reads_satisfied = 0;
   // Send back and requests buffers until the next one would fill the decoder
   // delay.
   while (demuxer_reads_satisfied < GetParam().decoding_delay - 1) {
     // Send a buffer back.
     demuxer_stream_->SatisfyReadAndHoldNext();
     base::RunLoop().RunUntilIdle();
     ++demuxer_reads_satisfied;
 
     // Decode one buffer.
-    decoder1_->SatisfySingleDecode();
+    decoder_->SatisfySingleDecode();
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(pending_read_);
     EXPECT_EQ(demuxer_reads_satisfied,
               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;
-  decoder2_->HoldNextInit();
-  decoder1_->SimulateError();
+
+  decoder_->SimulateError();
+  decoders_[1]->HoldNextInit();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(pending_read_);
   EXPECT_EQ(demuxer_reads_satisfied,
             video_frame_stream_->get_pending_buffers_size_for_testing());
 
-  decoder2_->SatisfyInit();
-  decoder2_->HoldDecode();
+  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());
 
-  decoder2_->SatisfyDecode();
+  decoder_->SatisfyDecode();
   base::RunLoop().RunUntilIdle();
 
-  // Make sure all buffers consumed by |decoder2_| have come from the fallback.
-  // Pending buffers should not have been cleared yet.
+  // Make sure all buffers consumed by |decoders_[1]| 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();
-  decoder1_->SimulateError();
-  decoder2_->SimulateFailureToInit();
+  decoder_->SimulateError();
+  SimulateDecoderInitFailure({1});
   ReadOneFrame();
 
-  // |video_frame_stream_| should have fallen back to |decoder3_|
+  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 |decoder1_| or |decoder2_| right now, they might have been
+  // Can't check previously selected decoder(s) right now, they might have been
   // destroyed already.
-  ASSERT_GT(decoder3_->total_bytes_decoded(), 0);
+  ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 
   // Verify no frame was dropped.
   ReadAllFrames();
 }
 
 TEST_P(VideoFrameStreamTest, FallbackDecoder_SelectedOnInitThenDecodeErrors) {
-  decoder1_->SimulateFailureToInit();
-  decoder2_->HoldDecode();
+  SimulateDecoderInitFailure({0});
   Initialize();
+  ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
+
+  decoder_->HoldDecode();
   ReadOneFrame();
-  decoder2_->SimulateError();
+  decoder_->SimulateError();
   base::RunLoop().RunUntilIdle();
 
-  // |video_frame_stream_| should have fallen back to |decoder3_|
+  // |video_frame_stream_| should have fallen back to |decoders_[2]|
+  ASSERT_EQ(GetDecoderName(2), decoder_->GetDisplayName());
+
   ASSERT_FALSE(pending_read_);
   ASSERT_EQ(VideoFrameStream::OK, last_read_status_);
 
-  // Can't check |decoder1_| or |decoder2_| right now, they might have been
+  // Can't check previously selected decoder(s) right now, they might have been
   // destroyed already.
-  ASSERT_GT(decoder3_->total_bytes_decoded(), 0);
+  ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 
   // Verify no frame was dropped.
   ReadAllFrames();
 }
 
 TEST_P(VideoFrameStreamTest,
        FallbackDecoder_NotSelectedOnMidstreamDecodeError) {
   Initialize();
   ReadOneFrame();
 
   // Successfully received a frame.
   EXPECT_FALSE(pending_read_);
-  ASSERT_GT(decoder1_->total_bytes_decoded(), 0);
+  ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 
-  decoder1_->SimulateError();
+  decoder_->SimulateError();
 
   // The error must surface from Read() as DECODE_ERROR.
   while (last_read_status_ == VideoFrameStream::OK) {
     ReadOneFrame();
     base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(pending_read_);
   }
 
-  // Verify the error was surfaced, rather than falling back to |decoder2_|.
+  // Verify the error was surfaced, rather than falling back to other decoders.
+  ASSERT_EQ(GetDecoderName(0), decoder_->GetDisplayName());
   EXPECT_FALSE(pending_read_);
-  ASSERT_EQ(decoder2_->total_bytes_decoded(), 0);
   ASSERT_EQ(VideoFrameStream::DECODE_ERROR, last_read_status_);
 }
 
 TEST_P(VideoFrameStreamTest, DecoderErrorWhenNotReading) {
   Initialize();
-  decoder1_->HoldDecode();
+  decoder_->HoldDecode();
   ReadOneFrame();
   EXPECT_TRUE(pending_read_);
 
   // Satisfy decode requests until we get the first frame out.
   while (pending_read_) {
-    decoder1_->SatisfySingleDecode();
+    decoder_->SatisfySingleDecode();
     base::RunLoop().RunUntilIdle();
   }
 
   // Trigger an error in the decoding.
-  decoder1_->SimulateError();
+  decoder_->SimulateError();
 
   // 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) {
   Initialize();
-  decoder1_->SimulateFailureToInit();
-  ReadUntilDecoderReinitialized(decoder1_);
+  decoder_->SimulateFailureToInit();
+  ReadUntilDecoderReinitialized();
+  ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
   ReadAllFrames();
-  ASSERT_GT(decoder2_->total_bytes_decoded(), 0);
+  ASSERT_GT(decoder_->total_bytes_decoded(), 0);
 }
 
 TEST_P(VideoFrameStreamTest,
        FallbackDecoderSelectedOnFailureToReinitialize_Twice) {
   Initialize();
-  decoder1_->SimulateFailureToInit();
-  ReadUntilDecoderReinitialized(decoder1_);
+  decoder_->SimulateFailureToInit();
+  ReadUntilDecoderReinitialized();
+  ASSERT_EQ(GetDecoderName(1), decoder_->GetDisplayName());
   ReadOneFrame();
-  decoder2_->SimulateFailureToInit();
-  ReadUntilDecoderReinitialized(decoder2_);
+  decoder_->SimulateFailureToInit();
+  ReadUntilDecoderReinitialized();
+  ASSERT_EQ(GetDecoderName(2), decoder_->GetDisplayName());
   ReadAllFrames();
 }
 
 TEST_P(VideoFrameStreamTest, DecodeErrorAfterFallbackDecoderSelectionFails) {
   Initialize();
-  decoder1_->SimulateFailureToInit();
-  decoder2_->SimulateFailureToInit();
-  decoder3_->SimulateFailureToInit();
-  ReadUntilDecoderReinitialized(decoder1_);
+  decoder_->SimulateFailureToInit();
+  SimulateDecoderInitFailure({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();
-  decoder1_->SimulateFailureToInit();
+  decoder_->SimulateFailureToInit();
   EnterPendingState(DECODER_REINIT);
-  decoder2_->HoldNextInit();
+  decoders_[1]->HoldNextInit();
   SatisfyPendingCallback(DECODER_REINIT);
 }
 
 }  // namespace media