Remove calls to deprecated MessageLoop methods in media.

media/base/text_renderer_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 "media/base/text_renderer.h"
 
 #include <stddef.h>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/fake_text_track_stream.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/webvtt_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 34 matching lines @@
     text_renderer_.reset(
         new TextRenderer(message_loop_.task_runner(),
                          base::Bind(&TextRendererTest::OnAddTextTrack,
                                     base::Unretained(this))));
     text_renderer_->Initialize(base::Bind(&TextRendererTest::OnEnd,
                                           base::Unretained(this)));
   }
 
   void Destroy() {
     text_renderer_.reset();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void AddTextTrack(TextKind kind,
                     const std::string& name,
                     const std::string& language,
                     bool expect_read) {
     const size_t idx = text_track_streams_.size();
     text_track_streams_.push_back(new FakeTextTrackStream);
 
     if (expect_read)
       ExpectRead(idx);
 
     const TextTrackConfig config(kind, name, language, std::string());
     text_renderer_->AddTextStream(text_track_streams_.back(), config);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(text_tracks_.size(), text_track_streams_.size());
     FakeTextTrack* const text_track = text_tracks_.back();
     EXPECT_TRUE(text_track);
     EXPECT_TRUE(text_track->config_.Matches(config));
   }
 
   void OnAddTextTrack(const TextTrackConfig& config,
                       const AddTextTrackDoneCB& done_cb) {
     base::Closure destroy_cb =
@@ skipping 21 matching lines @@
                            const std::string& settings) {
     for (TextTrackStreams::iterator itr = text_track_streams_.begin();
          itr != text_track_streams_.end(); ++itr) {
       (*itr)->SatisfyPendingRead(start, duration, id, content, settings);
     }
   }
 
   void AbortPendingRead(unsigned idx) {
     FakeTextTrackStream* const stream = text_track_streams_[idx];
     stream->AbortPendingRead();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void AbortPendingReads() {
     for (size_t idx = 0; idx < text_track_streams_.size(); ++idx) {
       AbortPendingRead(idx);
     }
   }
 
   void SendEosNotification(unsigned idx) {
     FakeTextTrackStream* const stream = text_track_streams_[idx];
     stream->SendEosNotification();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void SendEosNotifications() {
     for (size_t idx = 0; idx < text_track_streams_.size(); ++idx) {
       SendEosNotification(idx);
     }
   }
 
   void SendCue(unsigned idx, bool expect_cue) {
     FakeTextTrackStream* const text_stream = text_track_streams_[idx];
 
     const base::TimeDelta start;
     const base::TimeDelta duration = base::TimeDelta::FromSeconds(42);
     const std::string id = "id";
     const std::string content = "subtitle";
     const std::string settings;
 
     if (expect_cue) {
       FakeTextTrack* const text_track = text_tracks_[idx];
       EXPECT_CALL(*text_track, addWebVTTCue(start,
                                             start + duration,
                                             id,
                                             content,
                                             settings));
     }
 
     text_stream->SatisfyPendingRead(start, duration, id, content, settings);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void SendCues(bool expect_cue) {
     for (size_t idx = 0; idx < text_track_streams_.size(); ++idx) {
       SendCue(idx, expect_cue);
     }
   }
 
   void OnDestroyTextTrack(unsigned idx) {
     text_tracks_[idx] = NULL;
   }
 
   void Play() {
     text_renderer_->StartPlaying();
   }
 
   void Pause() {
     text_renderer_->Pause(base::Bind(&TextRendererTest::OnPause,
                                      base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void Flush() {
     EXPECT_CALL(*this, OnFlush());
     text_renderer_->Flush(base::Bind(&TextRendererTest::OnFlush,
                                      base::Unretained(this)));
   }
 
   void ExpectRead(size_t idx) {
     FakeTextTrackStream* const stream = text_track_streams_[idx];
@@ skipping 1006 matching lines @@
   Play();
   AbortPendingRead(0);
   RemoveTextTrack(0);
   EXPECT_TRUE(text_renderer_->HasTracks());
   Pause();
   EXPECT_CALL(*this, OnPause());
   SendEosNotification(1);
 }
 
 }  // namespace media