Remove calls to deprecated MessageLoop methods in media.

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 "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::_;
@@ skipping 81 matching lines @@
 
   ~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;
     video_frame_stream_.reset();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     DCHECK(!pending_initialize_);
     DCHECK(!pending_read_);
     DCHECK(!pending_reset_);
     DCHECK(!pending_stop_);
   }
 
   MOCK_METHOD1(OnNewSpliceBuffer, void(base::TimeDelta));
   MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
 
@@ skipping 21 matching lines @@
 
   void InitializeVideoFrameStream() {
     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)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   // 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);
@@ skipping 27 matching lines @@
     DCHECK(!pending_read_);
     DCHECK(pending_reset_);
     pending_reset_ = false;
   }
 
   void ReadOneFrame() {
     frame_read_ = NULL;
     pending_read_ = true;
     video_frame_stream_->Read(base::Bind(
         &VideoFrameStreamTest::FrameReady, base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void ReadUntilPending() {
     do {
       ReadOneFrame();
     } while (!pending_read_);
   }
 
   void ReadAllFrames(int expected_decoded_frames) {
     do {
@@ skipping 58 matching lines @@
       case DECODER_DECODE:
         decoder->HoldDecode();
         ReadUntilPending();
         break;
 
       case DECODER_RESET:
         decoder->HoldNextReset();
         pending_reset_ = true;
         video_frame_stream_->Reset(base::Bind(&VideoFrameStreamTest::OnReset,
                                               base::Unretained(this)));
-        message_loop_.RunUntilIdle();
+        base::RunLoop().RunUntilIdle();
         break;
 
       case NOT_PENDING:
         NOTREACHED();
         break;
     }
   }
 
   void SatisfyPendingCallback(PendingState state) {
     SatisfyPendingCallback(state, decoder1_);
@@ skipping 27 matching lines @@
 
       case DECODER_RESET:
         decoder->SatisfyReset();
         break;
 
       case NOT_PENDING:
         NOTREACHED();
         break;
     }
 
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void Initialize() {
     EnterPendingState(DECODER_INIT);
     SatisfyPendingCallback(DECODER_INIT);
   }
 
   void Read() {
     EnterPendingState(DECODER_DECODE);
     SatisfyPendingCallback(DECODER_DECODE);
@@ skipping 107 matching lines @@
   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 (pending_read_) {
     ++demuxed_buffers;
     demuxer_stream_->SatisfyReadAndHoldNext();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   EXPECT_EQ(std::min(GetParam().decoding_delay + 1, kNumBuffersInOneConfig + 1),
             demuxed_buffers);
 
   // At this point the stream is waiting on read from the demuxer, but there is
   // no pending read from the stream. The stream should be blocked if we try
   // reading from it again.
   ReadUntilPending();
 
   demuxer_stream_->SatisfyRead();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   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();
   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();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     // Always keep one decode request pending.
     if (demuxed_buffers > 1) {
       decoder1_->SatisfySingleDecode();
-      message_loop_.RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     }
   }
 
   ReadUntilPending();
   EXPECT_TRUE(pending_read_);
 
   // Unblocking one decode request should unblock read even when demuxer is
   // still blocked.
   decoder1_->SatisfySingleDecode();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(pending_read_);
 
   // Stream should still be blocked on the demuxer after unblocking the decoder.
   decoder1_->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();
-  message_loop_.RunUntilIdle();
+  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();
 
   // 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();
-        message_loop_.RunUntilIdle();
+        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();
-  message_loop_.RunUntilIdle();
+  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));
 }
 
 // No Reset() before initialization is successfully completed.
@@ skipping 213 matching lines @@
 
   Initialize();
   decoder1_->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();
-  message_loop_.RunUntilIdle();
+  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();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   //  A frame should have been emited
   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);
 
   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_SelectedOnInitialDecodeError_Twice) {
   Initialize();
   decoder1_->SimulateError();
   decoder2_->HoldNextInit();
   ReadOneFrame();
 
   decoder2_->SatisfyInit();
   decoder2_->SimulateError();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // |video_frame_stream_| should have fallen back to |decoder3_|.
   ASSERT_FALSE(pending_read_);
   ASSERT_EQ(VideoFrameStream::OK, last_read_status_);
 
   // Can't check |decoder1_| or |decoder2_| right now, they might have been
   // destroyed already.
   ASSERT_GT(decoder3_->total_bytes_decoded(), 0);
 
   // Verify no frame was dropped.
@@ skipping 31 matching lines @@
   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();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // We want to make sure that |decoder2_| 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();
   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();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     ++demuxer_reads_satisfied;
 
     // Decode one buffer.
     decoder1_->SatisfySingleDecode();
-    message_loop_.RunUntilIdle();
+    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();
-  message_loop_.RunUntilIdle();
+  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();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // 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();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Make sure all buffers consumed by |decoder2_| 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_EQ(video_frame_stream_->get_previous_decoder_for_testing(), decoder1_);
   EXPECT_TRUE(pending_read_);
 
   // Give the decoder one more buffer, enough to release a frame.
   demuxer_stream_->SatisfyReadAndHoldNext();
-  message_loop_.RunUntilIdle();
+  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();
 }
@@ skipping 15 matching lines @@
   // Verify no frame was dropped.
   ReadAllFrames();
 }
 
 TEST_P(VideoFrameStreamTest, FallbackDecoder_SelectedOnInitThenDecodeErrors) {
   decoder1_->SimulateFailureToInit();
   decoder2_->HoldDecode();
   Initialize();
   ReadOneFrame();
   decoder2_->SimulateError();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // |video_frame_stream_| should have fallen back to |decoder3_|
   ASSERT_FALSE(pending_read_);
   ASSERT_EQ(VideoFrameStream::OK, last_read_status_);
 
   // Can't check |decoder1_| or |decoder2_| right now, they might have been
   // destroyed already.
   ASSERT_GT(decoder3_->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);
 
   decoder1_->SimulateError();
 
   // The error must surface from Read() as DECODE_ERROR.
   while (last_read_status_ == VideoFrameStream::OK) {
     ReadOneFrame();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(pending_read_);
   }
 
   // Verify the error was surfaced, rather than falling back to |decoder2_|.
   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();
   ReadOneFrame();
   EXPECT_TRUE(pending_read_);
 
   // Satisfy decode requests until we get the first frame out.
   while (pending_read_) {
     decoder1_->SatisfySingleDecode();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   // Trigger an error in the decoding.
   decoder1_->SimulateError();
 
   // The error must surface from Read() as DECODE_ERROR.
   while (last_read_status_ == VideoFrameStream::OK) {
     ReadOneFrame();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(pending_read_);
   }
   EXPECT_EQ(VideoFrameStream::DECODE_ERROR, last_read_status_);
 }
 
 TEST_P(VideoFrameStreamTest, FallbackDecoderSelectedOnFailureToReinitialize) {
   Initialize();
   decoder1_->SimulateFailureToInit();
   // Holding decode, because large decoder delays might cause us to get rid of
   // |previous_decoder_| before we are in a pending state again.
   decoder2_->HoldDecode();
   ReadUntilDecoderReinitialized(decoder1_);
   ASSERT_TRUE(video_frame_stream_->get_previous_decoder_for_testing());
   decoder2_->SatisfyDecode();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ReadAllFrames();
   ASSERT_FALSE(video_frame_stream_->get_previous_decoder_for_testing());
 }
 
 TEST_P(VideoFrameStreamTest,
        FallbackDecoderSelectedOnFailureToReinitialize_Twice) {
   Initialize();
   decoder1_->SimulateFailureToInit();
   ReadUntilDecoderReinitialized(decoder1_);
   ReadOneFrame();
   decoder2_->SimulateFailureToInit();
   ReadUntilDecoderReinitialized(decoder2_);
   ReadAllFrames();
 }
 
 TEST_P(VideoFrameStreamTest, DecodeErrorAfterFallbackDecoderSelectionFails) {
   Initialize();
   decoder1_->SimulateFailureToInit();
   decoder2_->SimulateFailureToInit();
   decoder3_->SimulateFailureToInit();
   ReadUntilDecoderReinitialized(decoder1_);
   // The error will surface from Read() as DECODE_ERROR.
   while (last_read_status_ == VideoFrameStream::OK) {
     ReadOneFrame();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(pending_read_);
   }
   EXPECT_EQ(VideoFrameStream::DECODE_ERROR, last_read_status_);
 }
 
 TEST_P(VideoFrameStreamTest, Destroy_DuringFallbackDecoderSelection) {
   Initialize();
   decoder1_->SimulateFailureToInit();
   EnterPendingState(DECODER_REINIT);
   decoder2_->HoldNextInit();
   SatisfyPendingCallback(DECODER_REINIT);
 }
 
 }  // namespace media