Remove calls to deprecated MessageLoop methods in media.

media/base/demuxer_perftest.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 <stddef.h>
 #include <stdint.h>
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.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/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/base/media.h"
 #include "media/base/media_log.h"
 #include "media/base/media_tracks.h"
 #include "media/base/test_data_util.h"
 #include "media/base/timestamp_constants.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/file_data_source.h"
@@ skipping 18 matching lines @@
                      const media::TextTrackConfig& config) override {}
   void RemoveTextStream(media::DemuxerStream* text_stream) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DemuxerHostImpl);
 };
 
 static void QuitLoopWithStatus(base::MessageLoop* message_loop,
                                media::PipelineStatus status) {
   CHECK_EQ(status, media::PIPELINE_OK);
-  message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  message_loop->task_runner()->PostTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 static void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                      const std::vector<uint8_t>& init_data) {
   VLOG(0) << "File is encrypted.";
 }
 
 static void OnMediaTracksUpdated(std::unique_ptr<MediaTracks> tracks) {
   VLOG(0) << "Got media tracks info, tracks = " << tracks->tracks().size();
 }
@@ skipping 59 matching lines @@
 StreamReader::~StreamReader() {}
 
 void StreamReader::Read() {
   int index = GetNextStreamIndexToRead();
   bool end_of_stream = false;
   base::TimeDelta timestamp;
 
   streams_[index]->Read(base::Bind(
       &StreamReader::OnReadDone, base::Unretained(this),
       base::MessageLoop::current(), &end_of_stream, &timestamp));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CHECK(end_of_stream || timestamp != media::kNoTimestamp());
   end_of_stream_[index] = end_of_stream;
   last_read_timestamp_[index] = timestamp;
   counts_[index]++;
 }
 
 bool StreamReader::IsDone() {
   for (size_t i = 0; i < end_of_stream_.size(); ++i) {
     if (!end_of_stream_[i])
       return false;
   }
   return true;
 }
 
 void StreamReader::OnReadDone(
     base::MessageLoop* message_loop,
     bool* end_of_stream,
     base::TimeDelta* timestamp,
     media::DemuxerStream::Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
   CHECK_EQ(status, media::DemuxerStream::kOk);
   CHECK(buffer.get());
   *end_of_stream = buffer->end_of_stream();
   *timestamp = *end_of_stream ? media::kNoTimestamp() : buffer->timestamp();
-  message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  message_loop->task_runner()->PostTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 int StreamReader::GetNextStreamIndexToRead() {
   int index = -1;
   for (int i = 0; i < number_of_streams(); ++i) {
     // Ignore streams at EOS.
     if (end_of_stream_[i])
       continue;
 
     // Use a stream if it hasn't been read from yet.
@@ skipping 23 matching lines @@
         base::Bind(&OnEncryptedMediaInitData);
     Demuxer::MediaTracksUpdatedCB tracks_updated_cb =
         base::Bind(&OnMediaTracksUpdated);
     FFmpegDemuxer demuxer(message_loop.task_runner(), &data_source,
                           encrypted_media_init_data_cb, tracks_updated_cb,
                           new MediaLog());
 
     demuxer.Initialize(&demuxer_host,
                        base::Bind(&QuitLoopWithStatus, &message_loop),
                        false);
-    message_loop.Run();
+    base::RunLoop().Run();
     StreamReader stream_reader(&demuxer, false);
 
     // Benchmark.
     base::TimeTicks start = base::TimeTicks::Now();
     while (!stream_reader.IsDone()) {
       stream_reader.Read();
     }
     base::TimeTicks end = base::TimeTicks::Now();
     total_time += (end - start).InSecondsF();
     demuxer.Stop();
     QuitLoopWithStatus(&message_loop, PIPELINE_OK);
-    message_loop.Run();
+    base::RunLoop().Run();
   }
 
   perf_test::PrintResult("demuxer_bench",
                          "",
                          filename,
                          kBenchmarkIterations / total_time,
                          "runs/s",
                          true);
 }
 
@@ skipping 13 matching lines @@
 #endif
 #if defined(OS_CHROMEOS)
   RunDemuxerBenchmark("bear.flac");
 #endif
 #if defined(USE_PROPRIETARY_CODECS) && defined(OS_CHROMEOS)
   RunDemuxerBenchmark("bear.avi");
 #endif
 }
 
 }  // namespace media