Remove calls to deprecated MessageLoop methods in media.

media/renderers/video_renderer_impl_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 <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/stack_trace.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/data_buffer.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/limits.h"
 #include "media/base/mock_filters.h"
@@ skipping 99 matching lines @@
                                      base::Unretained(&time_source_)),
                           status_cb);
   }
 
   void StartPlayingFrom(int milliseconds) {
     SCOPED_TRACE(base::StringPrintf("StartPlayingFrom(%d)", milliseconds));
     const base::TimeDelta media_time =
         base::TimeDelta::FromMilliseconds(milliseconds);
     time_source_.SetMediaTime(media_time);
     renderer_->StartPlayingFrom(media_time);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void Flush() {
     SCOPED_TRACE("Flush()");
     WaitableMessageLoopEvent event;
     renderer_->Flush(event.GetClosure());
     event.RunAndWait();
   }
 
   void Destroy() {
     SCOPED_TRACE("Destroy()");
     renderer_.reset();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   // Parses a string representation of video frames and generates corresponding
   // VideoFrame objects in |decode_results_|.
   //
   // Syntax:
   //   nn - Queue a decoder buffer with timestamp nn * 1000us
   //   abort - Queue an aborted read
   //   error - Queue a decoder error
   //
@@ skipping 72 matching lines @@
     DCHECK(wait_for_pending_decode_cb_.is_null());
   }
 
   void SatisfyPendingDecode() {
     CHECK(!decode_cb_.is_null());
     CHECK(!decode_results_.empty());
 
     // Post tasks for OutputCB and DecodeCB.
     scoped_refptr<VideoFrame> frame = decode_results_.front().second;
     if (frame.get())
-      message_loop_.PostTask(FROM_HERE, base::Bind(output_cb_, frame));
-    message_loop_.PostTask(
+      message_loop_.task_runner()->PostTask(FROM_HERE,
+                                            base::Bind(output_cb_, frame));
+    message_loop_.task_runner()->PostTask(
         FROM_HERE, base::Bind(base::ResetAndReturn(&decode_cb_),
                               decode_results_.front().first));
     decode_results_.pop_front();
   }
 
   void SatisfyPendingDecodeWithEndOfStream() {
     DCHECK(!decode_cb_.is_null());
 
     // Return EOS buffer to trigger EOS frame.
     EXPECT_CALL(demuxer_stream_, Read(_))
         .WillOnce(RunCallback<0>(DemuxerStream::kOk,
                                  DecoderBuffer::CreateEOSBuffer()));
 
     // Satify pending |decode_cb_| to trigger a new DemuxerStream::Read().
-    message_loop_.PostTask(
+    message_loop_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(base::ResetAndReturn(&decode_cb_), DecodeStatus::OK));
 
     WaitForPendingDecode();
 
-    message_loop_.PostTask(
+    message_loop_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(base::ResetAndReturn(&decode_cb_), DecodeStatus::OK));
   }
 
   void AdvanceWallclockTimeInMs(int time_ms) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     base::AutoLock l(lock_);
     tick_clock_->Advance(base::TimeDelta::FromMilliseconds(time_ms));
   }
 
@@ skipping 186 matching lines @@
   }
 
   void FlushRequested(const base::Closure& callback) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     decode_results_.clear();
     if (!decode_cb_.is_null()) {
       QueueFrames("abort");
       SatisfyPendingDecode();
     }
 
-    message_loop_.PostTask(FROM_HERE, callback);
+    message_loop_.task_runner()->PostTask(FROM_HERE, callback);
   }
 
   // Used to protect |time_|.
   base::Lock lock_;
   base::TimeDelta time_;
 
   // Used for satisfying reads.
   VideoDecoder::OutputCB output_cb_;
   VideoDecoder::DecodeCB decode_cb_;
   base::TimeDelta next_frame_timestamp_;
@@ skipping 636 matching lines @@
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
   EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   ASSERT_EQ(1u, frame_ready_cbs_.size());
 
   uint32_t frame_ready_index = 0;
   while (frame_ready_index < frame_ready_cbs_.size()) {
     frame_ready_cbs_[frame_ready_index++].Run();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
   Destroy();
 }
 
 TEST_F(VideoRendererImplAsyncAddFrameReadyTest, WeakFactoryDiscardsOneFrame) {
   Initialize();
   QueueFrames("0 10 20 30");
   StartPlayingFrom(0);
   Flush();
   ASSERT_EQ(1u, frame_ready_cbs_.size());
   // This frame will be discarded.
   frame_ready_cbs_.front().Run();
   Destroy();
 }
 
 }  // namespace media