[Chromecast] Use custom thread for mixer

This saves ~60 microseconds per posted task (~90% of posted task
overhead).

Bug: internal b/167285412
Change-Id: I1b644c0d5a68799e0852768078841831b6d437b3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2599583
Commit-Queue: Kenneth MacKay <kmackay@chromium.org>
Reviewed-by: Yuchen Liu <yucliu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#839019}

chromecast/media/cma/backend/mixer/audio_output_redirector.cc

@@ -62,7 +62,7 @@ class AudioOutputRedirector::RedirectionConnection
  public:
   explicit RedirectionConnection(
       std::unique_ptr<mixer_service::MixerSocket> socket,
-      scoped_refptr<base::SequencedTaskRunner> mixer_task_runner,
+      scoped_refptr<base::TaskRunner> mixer_task_runner,
       base::WeakPtr<AudioOutputRedirector> redirector)
       : socket_(std::move(socket)),
         mixer_task_runner_(std::move(mixer_task_runner)),
@@ -135,7 +135,7 @@ class AudioOutputRedirector::RedirectionConnection
   }
 
   const std::unique_ptr<mixer_service::MixerSocket> socket_;
-  const scoped_refptr<base::SequencedTaskRunner> mixer_task_runner_;
+  const scoped_refptr<base::TaskRunner> mixer_task_runner_;
   const base::WeakPtr<AudioOutputRedirector> redirector_;
 
   bool error_ = false;

chromecast/media/cma/backend/mixer/stream_mixer.h

@@ -18,10 +18,10 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequence_checker.h"
 #include "base/sequenced_task_runner.h"
-#include "base/single_thread_task_runner.h"
+#include "base/task_runner.h"
 #include "base/threading/sequence_bound.h"
-#include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "chromecast/media/cma/backend/mixer/mixer_input.h"
 #include "chromecast/media/cma/backend/mixer/mixer_pipeline.h"
@@ -73,7 +73,7 @@ class StreamMixer {
 
   int num_output_channels() const { return num_output_channels_; }
 
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner() const {
+  scoped_refptr<base::TaskRunner> task_runner() const {
     return mixer_task_runner_;
   }
 
@@ -120,8 +120,7 @@ class StreamMixer {
   // Test-only methods.
   StreamMixer(
       std::unique_ptr<MixerOutputStream> output,
-      std::unique_ptr<base::Thread> mixer_thread,
-      scoped_refptr<base::SingleThreadTaskRunner> mixer_task_runner,
+      scoped_refptr<base::SequencedTaskRunner> mixer_task_runner,
       const std::string& pipeline_json,
       scoped_refptr<base::SequencedTaskRunner> io_task_runner = nullptr);
   void ResetPostProcessorsForTest(
@@ -140,6 +139,8 @@ class StreamMixer {
   };
   class ExternalMediaVolumeChangeRequestObserver;
 
+  class MixerThread;
+
   enum State {
     kStateStopped,
     kStateRunning,
@@ -165,6 +166,7 @@ class StreamMixer {
                                int input_samples_per_second);
   void SignalError(MixerInput::Source::MixerError error);
   int GetEffectiveChannelCount(MixerInput::Source* input_source);
+  void AddInputOnThread(MixerInput::Source* input_source);
   void RemoveInputOnThread(MixerInput::Source* input_source);
   void SetCloseTimeout();
   void UpdatePlayoutChannel();
@@ -173,10 +175,21 @@ class StreamMixer {
   void WriteOneBuffer();
   void WriteMixedPcm(int frames, int64_t expected_playback_time);
 
+  void UpdateStreamCountsOnThread();
+  void SetVolumeOnThread(AudioContentType type, float level);
+  void SetMutedOnThread(AudioContentType type, bool muted);
+  void SetOutputLimitOnThread(AudioContentType type, float limit);
+  void SetVolumeMultiplierOnThread(MixerInput::Source* source,
+                                   float multiplier);
+  void SetPostProcessorConfigOnThread(std::string name, std::string config);
+  void AddAudioOutputRedirectorOnThread(
+      std::unique_ptr<AudioOutputRedirector> redirector);
   void RemoveAudioOutputRedirectorOnThread(AudioOutputRedirector* redirector);
 
   int GetSampleRateForDeviceId(const std::string& device);
 
+  void OnHealthCheckFailed();
+
   MediaPipelineBackend::AudioDecoder::RenderingDelay GetTotalRenderingDelay(
       FilterGroup* filter_group);
 
@@ -184,16 +197,15 @@ class StreamMixer {
   std::unique_ptr<PostProcessingPipelineFactory>
       post_processing_pipeline_factory_;
   std::unique_ptr<MixerPipeline> mixer_pipeline_;
-  std::unique_ptr<base::Thread> mixer_thread_;
-  scoped_refptr<base::SingleThreadTaskRunner> mixer_task_runner_;
+  SEQUENCE_CHECKER(mixer_sequence_checker_);
+  scoped_refptr<MixerThread> mixer_thread_;
+  scoped_refptr<base::TaskRunner> mixer_task_runner_;
   scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
   std::unique_ptr<ThreadHealthChecker> health_checker_;
 
   std::unique_ptr<InterleavedChannelMixer> loopback_channel_mixer_;
   std::unique_ptr<InterleavedChannelMixer> output_channel_mixer_;
 
-  void OnHealthCheckFailed();
-
   bool enable_dynamic_channel_count_;
   const int low_sample_rate_cutoff_;
   int fixed_num_output_channels_;

chromecast/media/cma/backend/mixer/stream_mixer_external_audio_pipeline_unittest.cc

@@ -83,7 +83,7 @@ class ExternalAudioPipelineTest : public ::testing::Test {
     external_audio_pipeline_support_->SetSupported();
 
     mixer_ = std::make_unique<StreamMixer>(
-        nullptr, nullptr, base::ThreadTaskRunnerHandle::Get(), "{}");
+        nullptr, base::ThreadTaskRunnerHandle::Get(), "{}");
   }
 
   void TearDown() override {

chromecast/media/cma/backend/mixer/stream_mixer_unittest.cc

@@ -379,7 +379,7 @@ class StreamMixerTest : public testing::Test {
     auto output = std::make_unique<NiceMock<MockMixerOutput>>();
     mock_output_ = output.get();
     mixer_ = std::make_unique<StreamMixer>(
-        std::move(output), nullptr, base::ThreadTaskRunnerHandle::Get(), "{}");
+        std::move(output), base::ThreadTaskRunnerHandle::Get(), "{}");
     mixer_->SetVolume(AudioContentType::kMedia, 1.0f);
     mixer_->SetVolume(AudioContentType::kAlarm, 1.0f);
     std::string test_pipeline_json = base::StringPrintf(