Remove calls to deprecated MessageLoop methods in media.

media/filters/chunk_demuxer_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 "media/filters/chunk_demuxer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 973 matching lines @@
     EXPECT_TRUE(AppendData(bear1->data() + 72737, 28183));
     CheckExpectedRanges("{ [0,2736) }");
 
     MarkEndOfStream(PIPELINE_OK);
     return true;
   }
 
   void ShutdownDemuxer() {
     if (demuxer_) {
       demuxer_->Shutdown();
-      message_loop_.RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     }
   }
 
   void AddSimpleBlock(ClusterBuilder* cb, int track_num, int64_t timecode) {
     uint8_t data[] = {0x00};
     cb->AddSimpleBlock(track_num, timecode, 0, data, sizeof(data));
   }
 
   std::unique_ptr<Cluster> GenerateCluster(int timecode, int block_count) {
     return GenerateCluster(timecode, timecode, block_count);
@@ skipping 97 matching lines @@
       cb.AddBlockGroup(track_number, timecode, block_duration,
                        kWebMFlagKeyframe, static_cast<bool>(kWebMFlagKeyframe),
                        &data[0], data.size());
     }
 
     return cb.Finish();
   }
 
   void Read(DemuxerStream::Type type, const DemuxerStream::ReadCB& read_cb) {
     demuxer_->GetStream(type)->Read(read_cb);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void ReadAudio(const DemuxerStream::ReadCB& read_cb) {
     Read(DemuxerStream::AUDIO, read_cb);
   }
 
   void ReadVideo(const DemuxerStream::ReadCB& read_cb) {
     Read(DemuxerStream::VIDEO, read_cb);
   }
 
@@ skipping 112 matching lines @@
       base::RunLoop().RunUntilIdle();
       if (*status == DemuxerStream::kOk && !buffer->end_of_stream())
         *last_timestamp = buffer->timestamp();
     } while (*status == DemuxerStream::kOk && !buffer->end_of_stream());
   }
 
   void ExpectEndOfStream(DemuxerStream::Type type) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk, IsEndOfStream()));
     demuxer_->GetStream(type)->Read(base::Bind(
         &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void ExpectRead(DemuxerStream::Type type, int64_t timestamp_in_ms) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk,
                                 HasTimestamp(timestamp_in_ms)));
     demuxer_->GetStream(type)->Read(base::Bind(
         &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void ExpectConfigChanged(DemuxerStream::Type type) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kConfigChanged, _));
     demuxer_->GetStream(type)->Read(base::Bind(
         &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void CheckExpectedBuffers(DemuxerStream* stream,
                             const std::string& expected) {
     std::vector<std::string> timestamps = base::SplitString(
         expected, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     std::stringstream ss;
     for (size_t i = 0; i < timestamps.size(); ++i) {
       // Initialize status to kAborted since it's possible for Read() to return
       // without calling StoreStatusAndBuffer() if it doesn't have any buffers
@@ skipping 91 matching lines @@
   MOCK_METHOD0(DemuxerOpened, void());
   MOCK_METHOD2(OnEncryptedMediaInitData,
                void(EmeInitDataType init_data_type,
                     const std::vector<uint8_t>& init_data));
 
   MOCK_METHOD1(InitSegmentReceivedMock, void(std::unique_ptr<MediaTracks>&));
 
   void Seek(base::TimeDelta seek_time) {
     demuxer_->StartWaitingForSeek(seek_time);
     demuxer_->Seek(seek_time, NewExpectedStatusCB(PIPELINE_OK));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void MarkEndOfStream(PipelineStatus status) {
     demuxer_->MarkEndOfStream(status);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   bool SetTimestampOffset(const std::string& id,
                           base::TimeDelta timestamp_offset) {
     if (demuxer_->IsParsingMediaSegment(id))
       return false;
 
     timestamp_offset_map_[id] = timestamp_offset;
     return true;
   }
@@ skipping 331 matching lines @@
 
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done = false;
   bool video_read_done = false;
   bool text_read_done = false;
   audio_stream->Read(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
   video_stream->Read(base::Bind(&OnReadDone_EOSExpected, &video_read_done));
   text_stream->Read(base::Bind(&OnReadDone_EOSExpected, &text_read_done));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
   EXPECT_FALSE(text_read_done);
 
   ShutdownDemuxer();
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
   EXPECT_TRUE(text_read_done);
@@ skipping 10 matching lines @@
   EXPECT_CALL(*this, Checkpoint(1));
 
   Seek(base::TimeDelta::FromMilliseconds(46));
 
   EXPECT_CALL(*this, Checkpoint(2));
 
   Checkpoint(1);
 
   ASSERT_TRUE(AppendCluster(kDefaultSecondCluster()));
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   Checkpoint(2);
 }
 
 // Test that parsing errors are handled for clusters appended after init.
 TEST_F(ChunkDemuxerTest, ErrorWhileParsingClusterAfterInit) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   EXPECT_MEDIA_LOG(StreamParsingFailed());
@@ skipping 287 matching lines @@
   bool video_read_done_1 = false;
   EndOfStreamHelper end_of_stream_helper_1(demuxer_.get());
   EndOfStreamHelper end_of_stream_helper_2(demuxer_.get());
 
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done_1));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done_1));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(audio_read_done_1);
   EXPECT_TRUE(video_read_done_1);
 
   end_of_stream_helper_1.RequestReads();
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kVideoBlockDuration)));
   MarkEndOfStream(PIPELINE_OK);
 
@@ skipping 272 matching lines @@
                        &video_read_done));
 
   // Make sure the reads haven't completed yet.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   // Append data one byte at a time until one or both reads complete.
   int i = 0;
   for (; i < cluster->size() && !(audio_read_done || video_read_done); ++i) {
     ASSERT_TRUE(AppendData(cluster->data() + i, 1));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   EXPECT_TRUE(audio_read_done || video_read_done);
   EXPECT_GT(i, 0);
   EXPECT_LT(i, cluster->size());
 
   audio_read_done = false;
   video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(23),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(33),
                        &video_read_done));
 
   // Make sure the reads haven't completed yet.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   // Append the remaining data.
   ASSERT_LT(i, cluster->size());
   ASSERT_TRUE(AppendData(cluster->data() + i, cluster->size() - i));
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, ParseErrorDuringInit) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(kNoTimestamp(), CHUNK_DEMUXER_ERROR_APPEND_FAILED),
@@ skipping 183 matching lines @@
 
   // Read() from audio should return normal buffers.
   GenerateAudioStreamExpectedReads(0, 4);
 
   // Remove the audio id.
   demuxer_->RemoveId(audio_id);
 
   // Read() from audio should return "end of stream" buffers.
   bool audio_read_done = false;
   ReadAudio(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(audio_read_done);
 
   // Read() from video should still return normal buffers.
   GenerateVideoStreamExpectedReads(0, 4);
 }
 
 // Test that removing an ID immediately after adding it does not interfere with
 // quota for new IDs in the future.
 TEST_F(ChunkDemuxerTest, RemoveAndAddId) {
   std::string audio_id_1 = "audio1";
@@ skipping 18 matching lines @@
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone_AbortExpected, &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone_AbortExpected, &video_read_done));
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   // Now cancel the pending seek, which should flush the reads with empty
   // buffers.
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(0);
   demuxer_->CancelPendingSeek(seek_time);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // A seek back to the buffered region should succeed.
   Seek(seek_time);
   GenerateExpectedReads(0, 4);
 }
 
 TEST_F(ChunkDemuxerTest, SeekCanceledWhileWaitingForSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
@@ skipping 63 matching lines @@
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   ASSERT_TRUE(AppendCluster(
       audio_id, GenerateSingleStreamCluster(3000, 3092, kAudioTrackNum,
                                             kAudioBlockDuration)));
   ASSERT_TRUE(AppendCluster(
       video_id, GenerateSingleStreamCluster(3000, 3132, kVideoTrackNum,
                                             kVideoBlockDuration)));
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Read() should return buffers at 3.
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 // Test that Seek() completes successfully when EndOfStream
 // is called before data is available for that seek point.
 // This scenario might be useful if seeking past the end of stream
 // of either audio or video (or both).
 TEST_F(ChunkDemuxerTest, EndOfStreamAfterPastEosSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum,
                       "0K 10K 20K 30K 40K 50K 60K 70K 80K 90K 100K 110K", 10),
       MuxedStreamInfo(kVideoTrackNum, "0K 20K 40K 60K 80K", 20));
   CheckExpectedRanges("{ [0,100) }");
 
   // Seeking past the end of video.
   // Note: audio data is available for that seek point.
   bool seek_cb_was_called = false;
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(110);
   demuxer_->StartWaitingForSeek(seek_time);
   demuxer_->Seek(seek_time,
                  base::Bind(OnSeekDone_OKExpected, &seek_cb_was_called));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(seek_cb_was_called);
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(120)));
   MarkEndOfStream(PIPELINE_OK);
   CheckExpectedRanges("{ [0,120) }");
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(seek_cb_was_called);
 
   ShutdownDemuxer();
 }
 
 // Test that EndOfStream is ignored if coming during a pending seek
 // whose seek time is before some existing ranges.
 TEST_F(ChunkDemuxerTest, EndOfStreamDuringPendingSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum,
                       "0K 10K 20K 30K 40K 50K 60K 70K 80K 90K 100K 110K", 10),
       MuxedStreamInfo(kVideoTrackNum, "0K 20K 40K 60K 80K", 20));
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum,
                       "200K 210K 220K 230K 240K 250K 260K 270K 280K 290K", 10),
       MuxedStreamInfo(kVideoTrackNum, "200K 220K 240K 260K 280K", 20));
 
   bool seek_cb_was_called = false;
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(160);
   demuxer_->StartWaitingForSeek(seek_time);
   demuxer_->Seek(seek_time,
                  base::Bind(OnSeekDone_OKExpected, &seek_cb_was_called));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(seek_cb_was_called);
 
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(300)));
   MarkEndOfStream(PIPELINE_OK);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(seek_cb_was_called);
 
   demuxer_->UnmarkEndOfStream();
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "140K 150K 160K 170K", 10),
       MuxedStreamInfo(kVideoTrackNum, "140K 145K 150K 155K 160K 165K 170K 175K",
                       20));
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(seek_cb_was_called);
 
   ShutdownDemuxer();
 }
 
 // Test ranges in an audio-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
@@ skipping 927 matching lines @@
   MarkEndOfStream(PIPELINE_OK);
 }
 
 // Test receiving a Shutdown() call before we get an Initialize()
 // call. This can happen if video element gets destroyed before
 // the pipeline has a chance to initialize the demuxer.
 TEST_F(ChunkDemuxerTest, Shutdown_BeforeInitialize) {
   demuxer_->Shutdown();
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(DEMUXER_ERROR_COULD_NOT_OPEN), true);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Verifies that signaling end of stream while stalled at a gap
 // boundary does not trigger end of stream buffers to be returned.
 TEST_F(ChunkDemuxerTest, EndOfStreamWhileWaitingForGapToBeFilled) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   ASSERT_TRUE(AppendCluster(0, 10));
   ASSERT_TRUE(AppendCluster(300, 10));
   CheckExpectedRanges("{ [0,132) [300,432) }");
@@ skipping 17 matching lines @@
   MarkEndOfStream(PIPELINE_OK);
 
   // Verify that the reads still haven't completed.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   demuxer_->UnmarkEndOfStream();
 
   ASSERT_TRUE(AppendCluster(138, 22));
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   CheckExpectedRanges("{ [0,435) }");
 
   // Verify that the reads have completed.
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // Read the rest of the buffers.
   GenerateExpectedReads(161, 171, 20);
 
@@ skipping 552 matching lines @@
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(120);
   bool seek_cb_was_called = false;
   demuxer_->StartWaitingForSeek(seek_time);
   demuxer_->Seek(seek_time,
                  base::Bind(OnSeekDone_OKExpected, &seek_cb_was_called));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(seek_cb_was_called);
 
   bool text_read_done = false;
   text_stream->Read(base::Bind(&OnReadDone,
                                base::TimeDelta::FromMilliseconds(225),
                                &text_read_done));
 
   // Append audio & video data so the seek completes.
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum,
                       "0K 20K 40K 60K 80K 100K 120K 140K 160K 180K 200K", 20),
       MuxedStreamInfo(kVideoTrackNum, "0K 30 60 90 120K 150 180 210", 30));
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(seek_cb_was_called);
   EXPECT_FALSE(text_read_done);
 
   // Read some audio & video buffers to further verify seek completion.
   CheckExpectedBuffers(audio_stream, "120K 140K");
   CheckExpectedBuffers(video_stream, "120K 150");
 
   EXPECT_FALSE(text_read_done);
 
   // Append text cues that start after the seek point and verify that
   // they are returned by Read() calls.
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "220K 240K 260K 280K", 20),
                      MuxedStreamInfo(kVideoTrackNum, "240K 270 300 330", 30),
                      MuxedStreamInfo(kTextTrackNum, "225K 275K 325K"));
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(text_read_done);
 
   // NOTE: we start at 275 here because the buffer at 225 was returned
   // to the pending read initiated above.
   CheckExpectedBuffers(text_stream, "275K 325K");
 
   // Verify that audio & video streams continue to return expected values.
   CheckExpectedBuffers(audio_stream, "160K 180K");
   CheckExpectedBuffers(video_stream, "180 210");
 }
@@ skipping 314 matching lines @@
                          cluster->size() - video_start));
 
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,91) }");
   CheckExpectedRanges("{ [30,90) }");
   CheckExpectedBuffers(audio_stream, "30K 40K 50K 60K 70K 80K");
   CheckExpectedBuffers(video_stream, "71K 81");
 }
 
 }  // namespace media