Remove calls to deprecated MessageLoop methods in media.

media/filters/fake_video_decoder_unittest.cc

 // Copyright 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 "base/bind.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/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_frame.h"
 #include "media/filters/fake_video_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 static const int kTotalBuffers = 12;
@@ skipping 27 matching lines @@
 
   virtual ~FakeVideoDecoderTest() {
     Destroy();
   }
 
   void InitializeWithConfigAndExpectResult(const VideoDecoderConfig& config,
                                            bool success) {
     decoder_->Initialize(
         config, false, nullptr, NewExpectedBoolCB(success),
         base::Bind(&FakeVideoDecoderTest::FrameReady, base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     current_config_ = config;
   }
 
   void Initialize() {
     InitializeWithConfigAndExpectResult(TestVideoConfig::Normal(), true);
   }
 
   void EnterPendingInitState() {
     decoder_->HoldNextInit();
     Initialize();
   }
 
   void SatisfyInit() {
     decoder_->SatisfyInit();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   // Callback for VideoDecoder::Decode().
   void DecodeDone(DecodeStatus status) {
     DCHECK_GT(pending_decode_requests_, 0);
     --pending_decode_requests_;
     last_decode_status_ = status;
   }
 
   void FrameReady(const scoped_refptr<VideoFrame>& frame) {
@@ skipping 48 matching lines @@
     } else {
       buffer = DecoderBuffer::CreateEOSBuffer();
     }
 
     ++num_input_buffers_;
     ++pending_decode_requests_;
 
     decoder_->Decode(
         buffer,
         base::Bind(&FakeVideoDecoderTest::DecodeDone, base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void ReadOneFrame() {
     last_decoded_frame_ = NULL;
     do {
       Decode();
     } while (!last_decoded_frame_.get() && pending_decode_requests_ == 0);
   }
 
   void ReadAllFrames() {
     do {
       Decode();
     } while (num_input_buffers_ <= kTotalBuffers); // All input buffers + EOS.
   }
 
   void EnterPendingReadState() {
     // Pass the initial NOT_ENOUGH_DATA stage.
     ReadOneFrame();
     decoder_->HoldDecode();
     ReadOneFrame();
     ExpectReadResult(PENDING);
   }
 
   void SatisfyDecodeAndExpect(CallbackResult result) {
     decoder_->SatisfyDecode();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     ExpectReadResult(result);
   }
 
   void SatisfyRead() {
     SatisfyDecodeAndExpect(OK);
   }
 
   // Callback for VideoDecoder::Reset().
   void OnDecoderReset() {
     DCHECK(is_reset_pending_);
@@ skipping 10 matching lines @@
         break;
       default:
         NOTREACHED();
     }
   }
 
   void ResetAndExpect(CallbackResult result) {
     is_reset_pending_ = true;
     decoder_->Reset(base::Bind(&FakeVideoDecoderTest::OnDecoderReset,
                                base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     ExpectResetResult(result);
   }
 
   void EnterPendingResetState() {
     decoder_->HoldNextReset();
     ResetAndExpect(PENDING);
   }
 
   void SatisfyReset() {
     decoder_->SatisfyReset();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     ExpectResetResult(OK);
   }
 
   void Destroy() {
     decoder_.reset();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     // All pending callbacks must have been fired.
     DCHECK_EQ(pending_decode_requests_, 0);
     DCHECK(!is_reset_pending_);
   }
 
   base::MessageLoop message_loop_;
   VideoDecoderConfig current_config_;
 
   std::unique_ptr<FakeVideoDecoder> decoder_;
@@ skipping 103 matching lines @@
   Initialize();
 
   // Hold all decodes and satisfy one decode at a time.
   decoder_->HoldDecode();
   int num_decodes_satisfied = 0;
   while (num_decoded_frames_ == 0) {
     while (pending_decode_requests_ < decoder_->GetMaxDecodeRequests())
       Decode();
     decoder_->SatisfySingleDecode();
     ++num_decodes_satisfied;
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   DCHECK_EQ(num_decoded_frames_, 1);
   DCHECK_EQ(num_decodes_satisfied, GetParam().decoding_delay + 1);
 }
 
 TEST_P(FakeVideoDecoderTest, Reinitialize) {
   Initialize();
   ReadOneFrame();
   InitializeWithConfigAndExpectResult(TestVideoConfig::Large(), true);
@@ skipping 74 matching lines @@
 }
 
 TEST_P(FakeVideoDecoderTest, Destroy_DuringPendingReadAndPendingReset) {
   Initialize();
   EnterPendingReadState();
   EnterPendingResetState();
   Destroy();
 }
 
 }  // namespace media