Remove calls to deprecated MessageLoop methods in media.

media/filters/decrypting_demuxer_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 <stdint.h>
 
 #include <string>
 #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 "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/media_util.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
@@ skipping 52 matching lines @@
         input_video_stream_(
             new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         clear_buffer_(CreateFakeEncryptedStreamBuffer(true)),
         encrypted_buffer_(CreateFakeEncryptedStreamBuffer(false)),
         decrypted_buffer_(new DecoderBuffer(kFakeBufferSize)) {}
 
   virtual ~DecryptingDemuxerStreamTest() {
     if (is_initialized_)
       EXPECT_CALL(*decryptor_, CancelDecrypt(_));
     demuxer_stream_.reset();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void OnInitialized(PipelineStatus expected_status, PipelineStatus status) {
     EXPECT_EQ(expected_status, status);
     is_initialized_ = status == PIPELINE_OK;
   }
 
   void InitializeAudioAndExpectStatus(const AudioDecoderConfig& config,
                                       PipelineStatus expected_status) {
     input_audio_stream_->set_audio_decoder_config(config);
     demuxer_stream_->Initialize(
         input_audio_stream_.get(), cdm_context_.get(),
         base::Bind(&DecryptingDemuxerStreamTest::OnInitialized,
                    base::Unretained(this), expected_status));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void InitializeVideoAndExpectStatus(const VideoDecoderConfig& config,
                                       PipelineStatus expected_status) {
     input_video_stream_->set_video_decoder_config(config);
     demuxer_stream_->Initialize(
         input_video_stream_.get(), cdm_context_.get(),
         base::Bind(&DecryptingDemuxerStreamTest::OnInitialized,
                    base::Unretained(this), expected_status));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   enum CdmType { CDM_WITHOUT_DECRYPTOR, CDM_WITH_DECRYPTOR };
 
   void SetCdmType(CdmType cdm_type) {
     const bool has_decryptor = cdm_type == CDM_WITH_DECRYPTOR;
     EXPECT_CALL(*cdm_context_, GetDecryptor())
         .WillRepeatedly(Return(has_decryptor ? decryptor_.get() : nullptr));
   }
 
@@ skipping 29 matching lines @@
       const scoped_refptr<DecoderBuffer>& decrypted_buffer) {
     if (status != DemuxerStream::kOk)
       EXPECT_CALL(*this, BufferReady(status, IsNull()));
     else if (decrypted_buffer->end_of_stream())
       EXPECT_CALL(*this, BufferReady(status, IsEndOfStream()));
     else
       EXPECT_CALL(*this, BufferReady(status, decrypted_buffer));
 
     demuxer_stream_->Read(base::Bind(&DecryptingDemuxerStreamTest::BufferReady,
                                      base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void EnterClearReadingState() {
     EXPECT_TRUE(clear_buffer_->decrypt_config());
     EXPECT_CALL(*input_audio_stream_, Read(_))
         .WillOnce(ReturnBuffer(clear_buffer_));
 
     // For clearbuffer, decryptor->Decrypt() will not be called.
 
     scoped_refptr<DecoderBuffer> decrypted_buffer;
     EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, _))
         .WillOnce(SaveArg<1>(&decrypted_buffer));
     demuxer_stream_->Read(base::Bind(&DecryptingDemuxerStreamTest::BufferReady,
                                      base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     EXPECT_FALSE(decrypted_buffer->decrypt_config());
   }
 
   // Sets up expectations and actions to put DecryptingDemuxerStream in an
   // active normal reading state.
   void EnterNormalReadingState() {
     EXPECT_CALL(*input_audio_stream_, Read(_))
         .WillOnce(ReturnBuffer(encrypted_buffer_));
     EXPECT_CALL(*decryptor_, Decrypt(_, _, _))
         .WillOnce(RunCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
 
     ReadAndExpectBufferReadyWith(DemuxerStream::kOk, decrypted_buffer_);
   }
 
   // Make the read callback pending by saving and not firing it.
   void EnterPendingReadState() {
     EXPECT_TRUE(pending_demuxer_read_cb_.is_null());
     EXPECT_CALL(*input_audio_stream_, Read(_))
         .WillOnce(SaveArg<0>(&pending_demuxer_read_cb_));
     demuxer_stream_->Read(base::Bind(&DecryptingDemuxerStreamTest::BufferReady,
                                      base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     // Make sure the Read() triggers a Read() on the input demuxer stream.
     EXPECT_FALSE(pending_demuxer_read_cb_.is_null());
   }
 
   // Make the decrypt callback pending by saving and not firing it.
   void EnterPendingDecryptState() {
     EXPECT_TRUE(pending_decrypt_cb_.is_null());
     EXPECT_CALL(*input_audio_stream_, Read(_))
         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
     EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
         .WillOnce(SaveArg<2>(&pending_decrypt_cb_));
 
     demuxer_stream_->Read(base::Bind(&DecryptingDemuxerStreamTest::BufferReady,
                                      base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     // Make sure Read() triggers a Decrypt() on the decryptor.
     EXPECT_FALSE(pending_decrypt_cb_.is_null());
   }
 
   void EnterWaitingForKeyState() {
     EXPECT_CALL(*input_audio_stream_, Read(_))
         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
     EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
         .WillRepeatedly(RunCallback<2>(Decryptor::kNoKey,
                                        scoped_refptr<DecoderBuffer>()));
     EXPECT_CALL(*this, OnWaitingForDecryptionKey());
     demuxer_stream_->Read(base::Bind(&DecryptingDemuxerStreamTest::BufferReady,
                                      base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void AbortPendingDecryptCB() {
     if (!pending_decrypt_cb_.is_null()) {
       base::ResetAndReturn(&pending_decrypt_cb_).Run(Decryptor::kSuccess, NULL);
     }
   }
 
   void SatisfyPendingDemuxerReadCB(DemuxerStream::Status status) {
     scoped_refptr<DecoderBuffer> buffer =
         (status == DemuxerStream::kOk) ? encrypted_buffer_ : NULL;
     base::ResetAndReturn(&pending_demuxer_read_cb_).Run(status, buffer);
   }
 
   void Reset() {
     EXPECT_CALL(*decryptor_, CancelDecrypt(Decryptor::kAudio))
         .WillRepeatedly(InvokeWithoutArgs(
             this, &DecryptingDemuxerStreamTest::AbortPendingDecryptCB));
 
     demuxer_stream_->Reset(NewExpectedClosure());
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   MOCK_METHOD2(BufferReady, void(DemuxerStream::Status,
                                  const scoped_refptr<DecoderBuffer>&));
   MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
 
   base::MessageLoop message_loop_;
   std::unique_ptr<DecryptingDemuxerStream> demuxer_stream_;
   std::unique_ptr<StrictMock<MockCdmContext>> cdm_context_;
   std::unique_ptr<StrictMock<MockDecryptor>> decryptor_;
@@ skipping 89 matching lines @@
 // Test the case where the a key is added when the decryptor is in
 // kWaitingForKey state.
 TEST_F(DecryptingDemuxerStreamTest, KeyAdded_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
       .WillRepeatedly(RunCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
   EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, decrypted_buffer_));
   key_added_cb_.Run();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Test the case where the a key is added when the decryptor is in
 // kPendingDecrypt state.
 TEST_F(DecryptingDemuxerStreamTest, KeyAdded_DuringPendingDecrypt) {
   Initialize();
   EnterPendingDecryptState();
 
   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
       .WillRepeatedly(RunCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
   EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, decrypted_buffer_));
   // The decrypt callback is returned after the correct decryption key is added.
   key_added_cb_.Run();
   base::ResetAndReturn(&pending_decrypt_cb_).Run(Decryptor::kNoKey, NULL);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Test resetting in kIdle state but has not returned any buffer.
 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringIdleAfterInitialization) {
   Initialize();
   Reset();
 }
 
 // Test resetting in kIdle state after having returned one buffer.
 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringIdleAfterReadOneBuffer) {
   Initialize();
   EnterNormalReadingState();
   Reset();
 }
 
 // Test resetting in kPendingDemuxerRead state.
 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringPendingDemuxerRead) {
   Initialize();
   EnterPendingReadState();
 
   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 
   Reset();
   SatisfyPendingDemuxerReadCB(DemuxerStream::kOk);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Test resetting in kPendingDecrypt state.
 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringPendingDecrypt) {
   Initialize();
   EnterPendingDecryptState();
 
   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 
   Reset();
@@ skipping 31 matching lines @@
 // Test resetting when waiting for an aborted read.
 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringAbortedDemuxerRead) {
   Initialize();
   EnterPendingReadState();
 
   // Make sure we get a NULL audio frame returned.
   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 
   Reset();
   SatisfyPendingDemuxerReadCB(DemuxerStream::kAborted);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Test config change on the input demuxer stream.
 TEST_F(DecryptingDemuxerStreamTest, DemuxerRead_ConfigChanged) {
   Initialize();
 
   AudioDecoderConfig new_config(kCodecVorbis, kSampleFormatPlanarF32,
                                 CHANNEL_LAYOUT_STEREO, 88200, EmptyExtraData(),
                                 AesCtrEncryptionScheme());
   input_audio_stream_->set_audio_decoder_config(new_config);
 
   EXPECT_CALL(*input_audio_stream_, Read(_))
       .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
                                scoped_refptr<DecoderBuffer>()));
 
   ReadAndExpectBufferReadyWith(DemuxerStream::kConfigChanged, NULL);
 }
 
 // Test resetting when waiting for a config changed read.
 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringConfigChangedDemuxerRead) {
   Initialize();
   EnterPendingReadState();
 
   // Make sure we get a |kConfigChanged| instead of a |kAborted|.
   EXPECT_CALL(*this, BufferReady(DemuxerStream::kConfigChanged, IsNull()));
 
   Reset();
   SatisfyPendingDemuxerReadCB(DemuxerStream::kConfigChanged);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // The following tests test destruction in various scenarios. The destruction
 // happens in DecryptingDemuxerStreamTest's dtor.
 
 // Test destruction in kIdle state but has not returned any buffer.
 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringIdleAfterInitialization) {
   Initialize();
 }
 
@@ skipping 28 matching lines @@
 }
 
 // Test destruction after reset.
 TEST_F(DecryptingDemuxerStreamTest, Destroy_AfterReset) {
   Initialize();
   EnterNormalReadingState();
   Reset();
 }
 
 }  // namespace media