Remove calls to deprecated MessageLoop methods in media.

media/filters/ffmpeg_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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/path_service.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/media_log.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_helpers.h"
 #include "media/base/timestamp_constants.h"
 #include "media/ffmpeg/ffmpeg_common.h"
@@ skipping 139 matching lines @@
     EXPECT_EQ(status, DemuxerStream::kOk);
     EXPECT_TRUE(buffer.get() != NULL);
     EXPECT_EQ(read_expectation.size, buffer->data_size());
     EXPECT_EQ(read_expectation.timestamp_us,
               buffer->timestamp().InMicroseconds());
     EXPECT_EQ(read_expectation.discard_front_padding,
               buffer->discard_padding().first);
     EXPECT_EQ(read_expectation.is_key_frame, buffer->is_key_frame());
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     OnReadDoneCalled(read_expectation.size, read_expectation.timestamp_us);
-    message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+    message_loop_.task_runner()->PostTask(
+        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   DemuxerStream::ReadCB NewReadCB(const tracked_objects::Location& location,
                                   int size,
                                   int64_t timestamp_us,
                                   bool is_key_frame) {
     return NewReadCBWithCheckedDiscard(location,
                                        size,
                                        timestamp_us,
                                        base::TimeDelta(),
@@ skipping 52 matching lines @@
 
   int preferred_seeking_stream_index() const {
     return demuxer_->preferred_stream_for_seeking_.first;
   }
 
   void ReadUntilEndOfStream(DemuxerStream* stream) {
     bool got_eos_buffer = false;
     const int kMaxBuffers = 170;
     for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
       stream->Read(base::Bind(&EosOnReadDone, &got_eos_buffer));
-      message_loop_.Run();
+      base::RunLoop().Run();
     }
 
     EXPECT_TRUE(got_eos_buffer);
   }
 
  private:
   void CreateDataSource(const std::string& name) {
     CHECK(!data_source_);
 
     base::FilePath file_path;
@@ skipping 157 matching lines @@
 
 TEST_F(FFmpegDemuxerTest, Read_Audio) {
   // We test that on a successful audio packet read.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Attempt a read from the audio stream and run the message loop until done.
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   audio->Read(NewReadCB(FROM_HERE, 29, 0, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   audio->Read(NewReadCB(FROM_HERE, 27, 3000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   EXPECT_EQ(22084, demuxer_->GetMemoryUsage());
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Video) {
   // We test that on a successful video packet read.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   video->Read(NewReadCB(FROM_HERE, 1057, 33000, false));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   EXPECT_EQ(323, demuxer_->GetMemoryUsage());
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Text) {
   // We test that on a successful text packet read.
   CreateDemuxer("bear-vp8-webvtt.webm");
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   InitializeDemuxerWithText();
   ASSERT_TRUE(text_stream);
   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 
   text_stream->Read(NewReadCB(FROM_HERE, 31, 0, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   text_stream->Read(NewReadCB(FROM_HERE, 19, 500000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 TEST_F(FFmpegDemuxerTest, SeekInitialized_NoVideoStartTime) {
   CreateDemuxer("audio-start-time-only.webm");
   InitializeDemuxer();
   EXPECT_EQ(0, preferred_seeking_stream_index());
 }
 
 TEST_F(FFmpegDemuxerTest, Read_VideoPositiveStartTime) {
   const int64_t kTimelineOffsetMs = 1352550896000LL;
 
   // Test the start time is the first timestamp of the video and audio stream.
   CreateDemuxer("nonzero-start-time.webm");
   InitializeDemuxerWithTimelineOffset(
       base::Time::FromJsTime(kTimelineOffsetMs));
 
   // Attempt a read from the video stream and run the message loop until done.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   const base::TimeDelta video_start_time =
       base::TimeDelta::FromMicroseconds(400000);
   const base::TimeDelta audio_start_time =
       base::TimeDelta::FromMicroseconds(396000);
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     video->Read(NewReadCB(FROM_HERE, 5636, video_start_time.InMicroseconds(),
                           true));
-    message_loop_.Run();
+    base::RunLoop().Run();
     audio->Read(NewReadCB(FROM_HERE, 165, audio_start_time.InMicroseconds(),
                           true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     // Verify that the start time is equal to the lowest timestamp (ie the
     // audio).
     EXPECT_EQ(audio_start_time, demuxer_->start_time());
 
     // Verify that the timeline offset has not been adjusted by the start time.
     EXPECT_EQ(kTimelineOffsetMs, demuxer_->GetTimelineOffset().ToJavaTime());
 
     // Seek back to the beginning and repeat the test.
     WaitableMessageLoopEvent event;
     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 }
 
 TEST_F(FFmpegDemuxerTest, Read_AudioNoStartTime) {
   // FFmpeg does not set timestamps when demuxing wave files.  Ensure that the
   // demuxer sets a start time of zero in this case.
   CreateDemuxer("sfx_s24le.wav");
   InitializeDemuxer();
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     demuxer_->GetStream(DemuxerStream::AUDIO)
         ->Read(NewReadCB(FROM_HERE, 4095, 0, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
     EXPECT_EQ(base::TimeDelta(), demuxer_->start_time());
 
     // Seek back to the beginning and repeat the test.
     WaitableMessageLoopEvent event;
     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 }
 
 // TODO(dalecurtis): Test is disabled since FFmpeg does not currently guarantee
 // the order of demuxed packets in OGG containers.  Re-enable and fix key frame
 // expectations once we decide to either workaround it or attempt a fix
 // upstream.  See http://crbug.com/387996.
 TEST_F(FFmpegDemuxerTest,
        DISABLED_Read_AudioNegativeStartTimeAndOggDiscard_Bear) {
   // Many ogg files have negative starting timestamps, so ensure demuxing and
   // seeking work correctly with a negative start time.
   CreateDemuxer("bear.ogv");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     audio->Read(
         NewReadCBWithCheckedDiscard(FROM_HERE, 40, 0, kInfiniteDuration(),
                                     true));
-    message_loop_.Run();
+    base::RunLoop().Run();
     audio->Read(
         NewReadCBWithCheckedDiscard(FROM_HERE, 41, 2903, kInfiniteDuration(),
                                     true));
-    message_loop_.Run();
+    base::RunLoop().Run();
     audio->Read(NewReadCBWithCheckedDiscard(
         FROM_HERE, 173, 5805, base::TimeDelta::FromMicroseconds(10159), true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     audio->Read(NewReadCB(FROM_HERE, 148, 18866, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(-15964),
               demuxer_->start_time());
 
     video->Read(NewReadCB(FROM_HERE, 5751, 0, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     video->Read(NewReadCB(FROM_HERE, 846, 33367, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     video->Read(NewReadCB(FROM_HERE, 1255, 66733, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     // Seek back to the beginning and repeat the test.
     WaitableMessageLoopEvent event;
     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 }
 
 // Same test above, but using sync2.ogv which has video stream muxed before the
 // audio stream, so seeking based only on start time will fail since ffmpeg is
 // essentially just seeking based on file position.
 TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOggDiscard_Sync) {
   // Many ogg files have negative starting timestamps, so ensure demuxing and
   // seeking work correctly with a negative start time.
   CreateDemuxer("sync2.ogv");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     audio->Read(NewReadCBWithCheckedDiscard(
         FROM_HERE, 1, 0, base::TimeDelta::FromMicroseconds(2902), true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     audio->Read(NewReadCB(FROM_HERE, 1, 2902, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(-2902),
               demuxer_->start_time());
 
     // Though the internal start time may be below zero, the exposed media time
     // must always be greater than zero.
     EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 
     video->Read(NewReadCB(FROM_HERE, 9997, 0, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     video->Read(NewReadCB(FROM_HERE, 16, 33241, false));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     video->Read(NewReadCB(FROM_HERE, 631, 66482, false));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     // Seek back to the beginning and repeat the test.
     WaitableMessageLoopEvent event;
     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 }
 
 // Similar to the test above, but using an opus clip with a large amount of
 // pre-skip, which ffmpeg encodes as negative timestamps.
@@ skipping 11 matching lines @@
   static const int kTestExpectations[][2] = {
       {635, 0},      {594, 120000},  {597, 240000}, {591, 360000},
       {582, 480000}, {583, 600000},  {592, 720000}, {567, 840000},
       {579, 960000}, {572, 1080000}, {583, 1200000}};
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     for (size_t j = 0; j < arraysize(kTestExpectations); ++j) {
       audio->Read(NewReadCB(FROM_HERE, kTestExpectations[j][0],
                             kTestExpectations[j][1], true));
-      message_loop_.Run();
+      base::RunLoop().Run();
     }
 
     // Though the internal start time may be below zero, the exposed media time
     // must always be greater than zero.
     EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 
     video->Read(NewReadCB(FROM_HERE, 16009, 0, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     video->Read(NewReadCB(FROM_HERE, 2715, 1000, false));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     video->Read(NewReadCB(FROM_HERE, 427, 33000, false));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     // Seek back to the beginning and repeat the test.
     WaitableMessageLoopEvent event;
     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 }
 
 // Similar to the test above, but using sfx-opus.ogg, which has a much smaller
 // amount of discard padding and no |start_time| set on the AVStream.
 TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOpusSfxDiscard_Sync) {
   CreateDemuxer("sfx-opus.ogg");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
   EXPECT_EQ(audio->audio_decoder_config().codec_delay(), 312);
 
    // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     audio->Read(NewReadCB(FROM_HERE, 314, 0, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     audio->Read(NewReadCB(FROM_HERE, 244, 20000, true));
-    message_loop_.Run();
+    base::RunLoop().Run();
 
     // Though the internal start time may be below zero, the exposed media time
     // must always be greater than zero.
     EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 
     // Seek back to the beginning and repeat the test.
     WaitableMessageLoopEvent event;
     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
@@ skipping 13 matching lines @@
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   InitializeDemuxerWithText();
   ASSERT_TRUE(text_stream);
   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 
   bool got_eos_buffer = false;
   const int kMaxBuffers = 10;
   for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
     text_stream->Read(base::Bind(&EosOnReadDone, &got_eos_buffer));
-    message_loop_.Run();
+    base::RunLoop().Run();
   }
 
   EXPECT_TRUE(got_eos_buffer);
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
   set_duration_known(false);
@@ skipping 37 matching lines @@
   InitializeDemuxer();
 
   // Get our streams.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a video packet and release it.
   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Issue a simple forward seek, which should discard queued packets.
   WaitableMessageLoopEvent event;
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(1000000),
                  event.GetPipelineStatusCB());
   event.RunAndWaitForStatus(PIPELINE_OK);
 
   // Audio read #1.
   audio->Read(NewReadCB(FROM_HERE, 145, 803000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Audio read #2.
   audio->Read(NewReadCB(FROM_HERE, 148, 826000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Video read #1.
   video->Read(NewReadCB(FROM_HERE, 5425, 801000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Video read #2.
   video->Read(NewReadCB(FROM_HERE, 1906, 834000, false));
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 TEST_F(FFmpegDemuxerTest, SeekText) {
   // We're testing that the demuxer frees all queued packets when it receives
   // a Seek().
   CreateDemuxer("bear-vp8-webvtt.webm");
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   InitializeDemuxerWithText();
   ASSERT_TRUE(text_stream);
   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 
   // Get our streams.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a text packet and release it.
   text_stream->Read(NewReadCB(FROM_HERE, 31, 0, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Issue a simple forward seek, which should discard queued packets.
   WaitableMessageLoopEvent event;
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(1000000),
                  event.GetPipelineStatusCB());
   event.RunAndWaitForStatus(PIPELINE_OK);
 
   // Audio read #1.
   audio->Read(NewReadCB(FROM_HERE, 145, 803000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Audio read #2.
   audio->Read(NewReadCB(FROM_HERE, 148, 826000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Video read #1.
   video->Read(NewReadCB(FROM_HERE, 5425, 801000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Video read #2.
   video->Read(NewReadCB(FROM_HERE, 1906, 834000, false));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Text read #1.
   text_stream->Read(NewReadCB(FROM_HERE, 19, 500000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Text read #2.
   text_stream->Read(NewReadCB(FROM_HERE, 19, 1000000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 class MockReadCB {
  public:
   MockReadCB() {}
   ~MockReadCB() {}
 
   MOCK_METHOD2(Run, void(DemuxerStream::Status status,
                          const scoped_refptr<DecoderBuffer>& buffer));
  private:
@@ skipping 11 matching lines @@
   ASSERT_TRUE(audio);
 
   demuxer_->Stop();
 
   // Reads after being stopped are all EOS buffers.
   StrictMock<MockReadCB> callback;
   EXPECT_CALL(callback, Run(DemuxerStream::kOk, IsEndOfStreamBuffer()));
 
   // Attempt the read...
   audio->Read(base::Bind(&MockReadCB::Run, base::Unretained(&callback)));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Don't let the test call Stop() again.
   demuxer_.reset();
 }
 
 // Verify that seek works properly when the WebM cues data is at the start of
 // the file instead of at the end.
 TEST_F(FFmpegDemuxerTest, SeekWithCuesBeforeFirstCluster) {
   CreateDemuxer("bear-320x240-cues-in-front.webm");
   InitializeDemuxer();
 
   // Get our streams.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a video packet and release it.
   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Issue a simple forward seek, which should discard queued packets.
   WaitableMessageLoopEvent event;
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(2500000),
                  event.GetPipelineStatusCB());
   event.RunAndWaitForStatus(PIPELINE_OK);
 
   // Audio read #1.
   audio->Read(NewReadCB(FROM_HERE, 40, 2403000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Audio read #2.
   audio->Read(NewReadCB(FROM_HERE, 42, 2406000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Video read #1.
   video->Read(NewReadCB(FROM_HERE, 5276, 2402000, true));
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   // Video read #2.
   video->Read(NewReadCB(FROM_HERE, 1740, 2436000, false));
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 #if defined(USE_PROPRIETARY_CODECS)
 // Ensure ID3v1 tag reading is disabled.  id3_test.mp3 has an ID3v1 tag with the
 // field "title" set to "sample for id3 test".
 TEST_F(FFmpegDemuxerTest, NoID3TagData) {
   CreateDemuxer("id3_test.mp3");
   InitializeDemuxer();
   EXPECT_FALSE(av_dict_get(format_context()->metadata, "title", NULL, 0));
 }
@@ skipping 292 matching lines @@
 
   const MediaTrack& audio_track = *(media_tracks_->tracks()[1]);
   EXPECT_EQ(audio_track.type(), MediaTrack::Audio);
   EXPECT_EQ(audio_track.bytestream_track_id(), 2);
   EXPECT_EQ(audio_track.kind(), "main");
   EXPECT_EQ(audio_track.label(), "");
   EXPECT_EQ(audio_track.language(), "");
 }
 
 }  // namespace media