Replace FFmpegDemuxer thread per element with base::TaskScheduler.

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/strings/string_number_conversions.h"
+#include "base/test/scoped_task_scheduler.h"
 #include "base/threading/thread_task_runner_handle.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 16 matching lines @@
   void SetDuration(base::TimeDelta duration) override {}
   void OnDemuxerError(media::PipelineStatus error) override {}
   void AddTextStream(media::DemuxerStream* text_stream,
                      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,
+static void QuitLoopWithStatus(base::Closure quit_cb,
                                media::PipelineStatus status) {
   CHECK_EQ(status, media::PIPELINE_OK);
-  message_loop->task_runner()->PostTask(
-      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  quit_cb.Run();
 }
 
 static void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                      const std::vector<uint8_t>& init_data) {
-  VLOG(0) << "File is encrypted.";
+  DVLOG(1) << "File is encrypted.";
 }
 
 static void OnMediaTracksUpdated(std::unique_ptr<MediaTracks> tracks) {
-  VLOG(0) << "Got media tracks info, tracks = " << tracks->tracks().size();
+  DVLOG(1) << "Got media tracks info, tracks = " << tracks->tracks().size();
 }
 
 typedef std::vector<media::DemuxerStream* > Streams;
 
 // Simulates playback reading requirements by reading from each stream
 // present in |demuxer| in as-close-to-monotonically-increasing timestamp order.
 class StreamReader {
  public:
   StreamReader(media::Demuxer* demuxer, bool enable_bitstream_converter);
   ~StreamReader();
@@ skipping 95 matching lines @@
         last_read_timestamp_[i] < last_read_timestamp_[index]) {
       index = i;
     }
   }
   CHECK_GE(index, 0) << "Couldn't find a stream to read";
   return index;
 }
 
 static void RunDemuxerBenchmark(const std::string& filename) {
   base::FilePath file_path(GetTestDataFilePath(filename));
-  double total_time = 0.0;
+  base::TimeDelta total_time;
   for (int i = 0; i < kBenchmarkIterations; ++i) {
     // Setup.
-    base::MessageLoop message_loop;
+    base::test::ScopedTaskScheduler scoped_task_scheduler;
     DemuxerHostImpl demuxer_host;
     FileDataSource data_source;
     ASSERT_TRUE(data_source.Initialize(file_path));
 
     Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb =
         base::Bind(&OnEncryptedMediaInitData);
     Demuxer::MediaTracksUpdatedCB tracks_updated_cb =
         base::Bind(&OnMediaTracksUpdated);
-    FFmpegDemuxer demuxer(message_loop.task_runner(), &data_source,
+    FFmpegDemuxer demuxer(base::ThreadTaskRunnerHandle::Get(), &data_source,
                           encrypted_media_init_data_cb, tracks_updated_cb,
                           new MediaLog());
 
-    demuxer.Initialize(&demuxer_host,
-                       base::Bind(&QuitLoopWithStatus, &message_loop),
-                       false);
-    base::RunLoop().Run();
+    {
+      base::RunLoop run_loop;
+      demuxer.Initialize(
+          &demuxer_host,
+          base::Bind(&QuitLoopWithStatus, run_loop.QuitClosure()), false);
+      run_loop.Run();
+    }
+
     StreamReader stream_reader(&demuxer, false);
 
     // Benchmark.
     base::TimeTicks start = base::TimeTicks::Now();
-    while (!stream_reader.IsDone()) {
+    while (!stream_reader.IsDone())
       stream_reader.Read();
+    total_time += base::TimeTicks::Now() - start;
+    demuxer.Stop();
+
+    {
+      base::RunLoop run_loop;
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                    run_loop.QuitClosure());
+      run_loop.Run();

[gab, 2017/02/26 18:01:35]

This whole block can be replaced by base::RunLoop().RunUntilIdle(); I think
(unless you really care to strictly only run tasks already posted but not tasks
posted from those, if any?)

[DaleCurtis, 2017/02/27 21:26:30]

Done.

     }
-    base::TimeTicks end = base::TimeTicks::Now();
-    total_time += (end - start).InSecondsF();
-    demuxer.Stop();
-    QuitLoopWithStatus(&message_loop, PIPELINE_OK);
-    base::RunLoop().Run();
   }
 
-  perf_test::PrintResult("demuxer_bench",
-                         "",
-                         filename,
-                         kBenchmarkIterations / total_time,
-                         "runs/s",
-                         true);
+  perf_test::PrintResult("demuxer_bench", "", filename,
+                         kBenchmarkIterations / total_time.InSecondsF(),
+                         "runs/s", true);
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/399002
 #define MAYBE_Demuxer DISABLED_Demuxer
 #else
 #define MAYBE_Demuxer Demuxer
 #endif
 TEST(DemuxerPerfTest, MAYBE_Demuxer) {
   RunDemuxerBenchmark("bear.ogv");
   RunDemuxerBenchmark("bear-640x360.webm");
   RunDemuxerBenchmark("sfx_s16le.wav");
   RunDemuxerBenchmark("bear.flac");
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
   RunDemuxerBenchmark("bear-1280x720.mp4");
   RunDemuxerBenchmark("sfx.mp3");
 #endif
 #if BUILDFLAG(USE_PROPRIETARY_CODECS) && defined(OS_CHROMEOS)
   RunDemuxerBenchmark("bear.avi");
 #endif
 }
 
 }  // namespace media