[Chromecast] CastAudioManagerAndroid subclass AudioManagerAndroid

CastAudioManagerAndroid now becomes a subclass of AudioManagerAndroid,
instead of CastAudioManager. Some of the logics are moved into
CastAudioManagerAndroid to keep the behavior unchanged:
1. Move MakeLinear/LowLatencyOutputStream into CAMA, to return CAOS.
2. Move some getter into CastAudioManagerHelper (new), so that CAOS can
be created from both CAM and CAMA.

This will make switch to chromium audio output easier.

Bug: internal b/160753974
Test: Build, cast, cast_media_unittests
Change-Id: I99249c0c15bd7b5e9cf04b7ee10eb3b8850ee22e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2340104
Commit-Queue: Yuchen Liu <yucliu@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Reviewed-by: Frank Liberato <liberato@chromium.org>
Cr-Commit-Position: refs/heads/master@{#795689}

chromecast/browser/cast_content_browser_client.cc

@@ -290,10 +290,8 @@ CastContentBrowserClient::CreateAudioManager(
       base::BindRepeating(&CastContentBrowserClient::GetCmaBackendFactory,
                           base::Unretained(this)),
       base::BindRepeating(&shell::CastSessionIdMap::GetSessionId),
-      base::CreateSingleThreadTaskRunner({content::BrowserThread::UI}),
       GetMediaTaskRunner(),
-      ServiceConnector::MakeRemote(kBrowserProcessClientId),
-      BUILDFLAG(ENABLE_CAST_AUDIO_MANAGER_MIXER));
+      ServiceConnector::MakeRemote(kBrowserProcessClientId));
 #else
   return std::make_unique<media::CastAudioManager>(
       std::move(audio_thread), audio_log_factory,

chromecast/browser/cast_session_id_map.cc

@@ -63,7 +63,7 @@ void CastSessionIdMap::SetSessionId(std::string session_id,
 }
 
 // static
-std::string CastSessionIdMap::GetSessionId(std::string group_id) {
+std::string CastSessionIdMap::GetSessionId(const std::string& group_id) {
   return GetInstance()->GetSessionIdInternal(group_id);
 }
 
@@ -100,7 +100,8 @@ void CastSessionIdMap::SetSessionIdInternal(
   mapping_.emplace(group_id.ToString(), std::move(group_data));
 }
 
-std::string CastSessionIdMap::GetSessionIdInternal(std::string group_id) {
+std::string CastSessionIdMap::GetSessionIdInternal(
+    const std::string& group_id) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto it = mapping_.find(group_id);
   if (it != mapping_.end())

chromecast/browser/cast_session_id_map.h

@@ -42,7 +42,7 @@ class CastSessionIdMap {
   // Fetch the session id that is mapped to the provided group_id. Defaults to
   // empty string if the mapping is not found.
   // Must be called on the sequence for |task_runner_|.
-  static std::string GetSessionId(std::string group_id);
+  static std::string GetSessionId(const std::string& group_id);
 
  private:
   class GroupObserver;
@@ -64,7 +64,7 @@ class CastSessionIdMap {
                             std::unique_ptr<GroupObserver> group_observer);
   // Retrieves the session id for the provided group id.
   // This must be called on the |task_runner_|.
-  std::string GetSessionIdInternal(std::string group_id);
+  std::string GetSessionIdInternal(const std::string& group_id);
 
   base::flat_map<
       std::string,

chromecast/media/audio/BUILD.gn

@@ -90,6 +90,8 @@ cast_source_set("audio") {
     "cast_audio_input_stream.h",
     "cast_audio_manager.cc",
     "cast_audio_manager.h",
+    "cast_audio_manager_helper.cc",
+    "cast_audio_manager_helper.h",
     "cast_audio_mixer.cc",
     "cast_audio_mixer.h",
     "cast_audio_output_stream.cc",

chromecast/media/audio/cast_audio_manager.cc

@@ -46,7 +46,7 @@ CastAudioManager::CastAudioManager(
     std::unique_ptr<::media::AudioThread> audio_thread,
     ::media::AudioLogFactory* audio_log_factory,
     base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
-    GetSessionIdCallback get_session_id_callback,
+    CastAudioManagerHelper::GetSessionIdCallback get_session_id_callback,
     scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
     mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector,
@@ -65,24 +65,22 @@ CastAudioManager::CastAudioManager(
     std::unique_ptr<::media::AudioThread> audio_thread,
     ::media::AudioLogFactory* audio_log_factory,
     base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
-    GetSessionIdCallback get_session_id_callback,
+    CastAudioManagerHelper::GetSessionIdCallback get_session_id_callback,
     scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
     mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector,
     bool use_mixer,
     bool force_use_cma_backend_for_output)
     : AudioManagerBase(std::move(audio_thread), audio_log_factory),
-      backend_factory_getter_(std::move(backend_factory_getter)),
-      get_session_id_callback_(std::move(get_session_id_callback)),
+      helper_(this,
+              std::move(backend_factory_getter),
+              std::move(get_session_id_callback),
+              std::move(media_task_runner),
+              std::move(connector)),
       browser_task_runner_(std::move(browser_task_runner)),
-      media_task_runner_(std::move(media_task_runner)),
-      pending_connector_(std::move(connector)),
       force_use_cma_backend_for_output_(force_use_cma_backend_for_output),
       weak_factory_(this) {
   DCHECK(browser_task_runner_->BelongsToCurrentThread());
-  DCHECK(backend_factory_getter_);
-  DCHECK(get_session_id_callback_);
-  DCHECK(pending_connector_);
   weak_this_ = weak_factory_.GetWeakPtr();
   if (use_mixer)
     mixer_ = std::make_unique<CastAudioMixer>(this);
@@ -144,16 +142,6 @@ void CastAudioManager::ReleaseOutputStream(::media::AudioOutputStream* stream) {
   }
 }
 
-CmaBackendFactory* CastAudioManager::cma_backend_factory() {
-  if (!cma_backend_factory_)
-    cma_backend_factory_ = backend_factory_getter_.Run();
-  return cma_backend_factory_;
-}
-
-std::string CastAudioManager::GetSessionId(std::string audio_group_id) {
-  return get_session_id_callback_.Run(audio_group_id);
-}
-
 ::media::AudioOutputStream* CastAudioManager::MakeLinearOutputStream(
     const ::media::AudioParameters& params,
     const ::media::AudioManager::LogCallback& log_callback) {
@@ -164,8 +152,7 @@ std::string CastAudioManager::GetSessionId(std::string audio_group_id) {
     return mixer_->MakeStream(params);
   } else {
     return new CastAudioOutputStream(
-        this, GetConnector(), params,
-        ::media::AudioDeviceDescription::kDefaultDeviceId,
+        &helper_, params, ::media::AudioDeviceDescription::kDefaultDeviceId,
         UseMixerOutputStream(params));
   }
 }
@@ -185,7 +172,7 @@ std::string CastAudioManager::GetSessionId(std::string audio_group_id) {
     return mixer_->MakeStream(params);
   } else {
     return new CastAudioOutputStream(
-        this, GetConnector(), params,
+        &helper_, params,
         device_id_or_group_id.empty()
             ? ::media::AudioDeviceDescription::kDefaultDeviceId
             : device_id_or_group_id,
@@ -240,20 +227,11 @@ std::string CastAudioManager::GetSessionId(std::string audio_group_id) {
   // Keep a reference to this stream for proper behavior on
   // CastAudioManager::ReleaseOutputStream.
   mixer_output_stream_.reset(new CastAudioOutputStream(
-      this, GetConnector(), params,
-      ::media::AudioDeviceDescription::kDefaultDeviceId,
+      &helper_, params, ::media::AudioDeviceDescription::kDefaultDeviceId,
       UseMixerOutputStream(params)));
   return mixer_output_stream_.get();
 }
 
-chromecast::mojom::ServiceConnector* CastAudioManager::GetConnector() {
-  if (!connector_) {
-    DCHECK(pending_connector_);
-    connector_.Bind(std::move(pending_connector_));
-  }
-  return connector_.get();
-}
-
 bool CastAudioManager::UseMixerOutputStream(
     const ::media::AudioParameters& params) {
   bool use_cma_backend =

chromecast/media/audio/cast_audio_manager.h

@@ -13,6 +13,7 @@
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "chromecast/common/mojom/service_connector.mojom.h"
+#include "chromecast/media/audio/cast_audio_manager_helper.h"
 #include "media/audio/audio_manager_base.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -46,14 +47,11 @@ class CmaBackendFactory;
 
 class CastAudioManager : public ::media::AudioManagerBase {
  public:
-  using GetSessionIdCallback =
-      base::RepeatingCallback<std::string(std::string)>;
-
   CastAudioManager(
       std::unique_ptr<::media::AudioThread> audio_thread,
       ::media::AudioLogFactory* audio_log_factory,
       base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
-      GetSessionIdCallback get_session_id_callback,
+      CastAudioManagerHelper::GetSessionIdCallback get_session_id_callback,
       scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
       mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector,
@@ -72,13 +70,6 @@ class CastAudioManager : public ::media::AudioManagerBase {
   const char* GetName() override;
   void ReleaseOutputStream(::media::AudioOutputStream* stream) override;
 
-  CmaBackendFactory* cma_backend_factory();
-  base::SingleThreadTaskRunner* media_task_runner() {
-    return media_task_runner_.get();
-  }
-
-  std::string GetSessionId(std::string audio_group_id);
-
  protected:
   // AudioManagerBase implementation.
   ::media::AudioOutputStream* MakeLinearOutputStream(
@@ -109,13 +100,12 @@ class CastAudioManager : public ::media::AudioManagerBase {
   friend class CastAudioMixer;
   friend class CastAudioManagerTest;
   friend class CastAudioOutputStreamTest;
-  chromecast::mojom::ServiceConnector* GetConnector();
 
   CastAudioManager(
       std::unique_ptr<::media::AudioThread> audio_thread,
       ::media::AudioLogFactory* audio_log_factory,
       base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
-      GetSessionIdCallback get_session_id_callback,
+      CastAudioManagerHelper::GetSessionIdCallback get_session_id_callback,
       scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
       mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector,
@@ -126,19 +116,12 @@ class CastAudioManager : public ::media::AudioManagerBase {
   // stream audio playback.
   bool UseMixerOutputStream(const ::media::AudioParameters& params);
 
-  base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter_;
-  GetSessionIdCallback get_session_id_callback_;
-  CmaBackendFactory* cma_backend_factory_ = nullptr;
+  CastAudioManagerHelper helper_;
+
   scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   std::unique_ptr<::media::AudioOutputStream> mixer_output_stream_;
   std::unique_ptr<CastAudioMixer> mixer_;
 
-  // |connector_| is bound to |pending_connector_| lazily on first use, as it is
-  // created on the main thread but used on the Audio thread, which may differ.
-  mojo::PendingRemote<chromecast::mojom::ServiceConnector> pending_connector_;
-  mojo::Remote<chromecast::mojom::ServiceConnector> connector_;
-
   // Let unit test force the CastOutputStream to uses
   // CmaBackend implementation.
   // TODO(b/117980762): After refactoring CastOutputStream, so

chromecast/media/audio/cast_audio_manager_alsa.cc

@@ -82,7 +82,7 @@ CastAudioManagerAlsa::CastAudioManagerAlsa(
     std::unique_ptr<::media::AudioThread> audio_thread,
     ::media::AudioLogFactory* audio_log_factory,
     base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
-    GetSessionIdCallback get_session_id_callback,
+    CastAudioManagerHelper::GetSessionIdCallback get_session_id_callback,
     scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
     mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector,

chromecast/media/audio/cast_audio_manager_alsa.h

@@ -33,7 +33,7 @@ class CastAudioManagerAlsa : public CastAudioManager {
       std::unique_ptr<::media::AudioThread> audio_thread,
       ::media::AudioLogFactory* audio_log_factory,
       base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
-      GetSessionIdCallback get_session_id_callback,
+      CastAudioManagerHelper::GetSessionIdCallback get_session_id_callback,
       scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
       mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector,

chromecast/media/audio/cast_audio_manager_android.cc

@@ -9,6 +9,7 @@
 #include "base/logging.h"
 #include "chromecast/media/audio/audio_buildflags.h"
 #include "chromecast/media/audio/cast_audio_input_stream.h"
+#include "chromecast/media/audio/cast_audio_output_stream.h"
 #include "media/audio/android/audio_track_output_stream.h"
 #include "media/audio/audio_device_name.h"
 #include "media/base/audio_parameters.h"
@@ -29,19 +30,15 @@ CastAudioManagerAndroid::CastAudioManagerAndroid(
     std::unique_ptr<::media::AudioThread> audio_thread,
     ::media::AudioLogFactory* audio_log_factory,
     base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
-    GetSessionIdCallback get_session_id_callback,
-    scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
+    CastAudioManagerHelper::GetSessionIdCallback get_session_id_callback,
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-    mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector,
-    bool use_mixer)
-    : CastAudioManager(std::move(audio_thread),
-                       audio_log_factory,
+    mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector)
+    : ::media::AudioManagerAndroid(std::move(audio_thread), audio_log_factory),
+      helper_(this,
               std::move(backend_factory_getter),
               std::move(get_session_id_callback),
-                       browser_task_runner,
-                       media_task_runner,
-                       std::move(connector),
-                       use_mixer) {}
+              std::move(media_task_runner),
+              std::move(connector)) {}
 
 CastAudioManagerAndroid::~CastAudioManagerAndroid() = default;
 
@@ -107,6 +104,41 @@ void CastAudioManagerAndroid::GetAudioInputDeviceNames(
   return nullptr;
 }
 
+void CastAudioManagerAndroid::GetAudioOutputDeviceNames(
+    ::media::AudioDeviceNames* device_names) {
+  DCHECK(device_names->empty());
+  DCHECK(HasAudioOutputDevices());
+
+  // Default device name is added inside AudioManagerAndroid.
+  ::media::AudioManagerAndroid::GetAudioOutputDeviceNames(device_names);
+
+  device_names->push_back(::media::AudioDeviceName::CreateCommunications());
+}
+
+::media::AudioOutputStream* CastAudioManagerAndroid::MakeLinearOutputStream(
+    const ::media::AudioParameters& params,
+    const ::media::AudioManager::LogCallback& log_callback) {
+  DCHECK_EQ(::media::AudioParameters::AUDIO_PCM_LINEAR, params.format());
+
+  return new CastAudioOutputStream(
+      &helper_, params, ::media::AudioDeviceDescription::kDefaultDeviceId,
+      false /* use_mixer_service */);
+}
+
+::media::AudioOutputStream* CastAudioManagerAndroid::MakeLowLatencyOutputStream(
+    const ::media::AudioParameters& params,
+    const std::string& device_id_or_group_id,
+    const ::media::AudioManager::LogCallback& log_callback) {
+  DCHECK_EQ(::media::AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
+
+  return new CastAudioOutputStream(
+      &helper_, params,
+      device_id_or_group_id.empty()
+          ? ::media::AudioDeviceDescription::kDefaultDeviceId
+          : device_id_or_group_id,
+      false /* use_mixer_service */);
+}
+
 ::media::AudioOutputStream* CastAudioManagerAndroid::MakeBitstreamOutputStream(
     const ::media::AudioParameters& params,
     const std::string& device_id,

chromecast/media/audio/cast_audio_manager_android.h

@@ -9,35 +9,42 @@
 #include <string>
 
 #include "base/single_thread_task_runner.h"
-#include "chromecast/media/audio/cast_audio_manager.h"
+#include "chromecast/media/audio/cast_audio_manager_helper.h"
+#include "media/audio/android/audio_manager_android.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 namespace chromecast {
 namespace media {
 
-class CastAudioManagerAndroid : public CastAudioManager {
+class CastAudioManagerAndroid : public ::media::AudioManagerAndroid {
  public:
   CastAudioManagerAndroid(
       std::unique_ptr<::media::AudioThread> audio_thread,
       ::media::AudioLogFactory* audio_log_factory,
       base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
-      GetSessionIdCallback get_session_id_callback,
-      scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
+      CastAudioManagerHelper::GetSessionIdCallback get_session_id_callback,
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-      mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector,
-      bool use_mixer);
+      mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector);
   ~CastAudioManagerAndroid() override;
 
   // AudioManager implementation.
+  void GetAudioOutputDeviceNames(
+      ::media::AudioDeviceNames* device_names) override;
   ::media::AudioOutputStream* MakeAudioOutputStreamProxy(
       const ::media::AudioParameters& params,
       const std::string& device_id) override;
+  ::media::AudioOutputStream* MakeLinearOutputStream(
+      const ::media::AudioParameters& params,
+      const ::media::AudioManager::LogCallback& log_callback) override;
+  ::media::AudioOutputStream* MakeLowLatencyOutputStream(
+      const ::media::AudioParameters& params,
+      const std::string& device_id_or_group_id,
+      const ::media::AudioManager::LogCallback& log_callback) override;
   ::media::AudioOutputStream* MakeBitstreamOutputStream(
       const ::media::AudioParameters& params,
       const std::string& device_id,
       const ::media::AudioManager::LogCallback& log_callback) override;
 
-  // CastAudioManager implementation.
   bool HasAudioInputDevices() override;
   void GetAudioInputDeviceNames(
       ::media::AudioDeviceNames* device_names) override;
@@ -55,6 +62,8 @@ class CastAudioManagerAndroid : public CastAudioManager {
       const std::string& device_id,
       const ::media::AudioManager::LogCallback& log_callback) override;
 
+  CastAudioManagerHelper helper_;
+
   CastAudioManagerAndroid(const CastAudioManagerAndroid&) = delete;
   CastAudioManagerAndroid& operator=(const CastAudioManagerAndroid&) = delete;
 };

chromecast/media/audio/cast_audio_manager_helper.cc

+// Copyright 2020 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 "chromecast/media/audio/cast_audio_manager_helper.h"
+
+#include <utility>
+
+#include "base/check.h"
+#include "base/single_thread_task_runner.h"
+
+namespace chromecast {
+namespace media {
+
+CastAudioManagerHelper::CastAudioManagerHelper(
+    ::media::AudioManagerBase* audio_manager,
+    base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
+    GetSessionIdCallback get_session_id_callback,
+    scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+    mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector)
+    : audio_manager_(audio_manager),
+      backend_factory_getter_(std::move(backend_factory_getter)),
+      get_session_id_callback_(std::move(get_session_id_callback)),
+      media_task_runner_(std::move(media_task_runner)),
+      pending_connector_(std::move(connector)) {
+  DCHECK(audio_manager_);
+  DCHECK(backend_factory_getter_);
+  DCHECK(get_session_id_callback_);
+  DCHECK(pending_connector_);
+}
+
+CastAudioManagerHelper::~CastAudioManagerHelper() = default;
+
+CmaBackendFactory* CastAudioManagerHelper::GetCmaBackendFactory() {
+  if (!cma_backend_factory_)
+    cma_backend_factory_ = backend_factory_getter_.Run();
+  return cma_backend_factory_;
+}
+
+std::string CastAudioManagerHelper::GetSessionId(
+    const std::string& audio_group_id) {
+  return get_session_id_callback_.Run(audio_group_id);
+}
+
+chromecast::mojom::ServiceConnector* CastAudioManagerHelper::GetConnector() {
+  if (!connector_) {
+    DCHECK(pending_connector_);
+    connector_.Bind(std::move(pending_connector_));
+  }
+  return connector_.get();
+}
+
+}  // namespace media
+}  // namespace chromecast

chromecast/media/audio/cast_audio_manager_helper.h

+// Copyright 2020 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.
+
+#ifndef CHROMECAST_MEDIA_AUDIO_CAST_AUDIO_MANAGER_HELPER_H_
+#define CHROMECAST_MEDIA_AUDIO_CAST_AUDIO_MANAGER_HELPER_H_
+
+#include <string>
+
+#include "base/callback.h"
+#include "base/memory/scoped_refptr.h"
+#include "chromecast/common/mojom/service_connector.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}  // namespace base
+
+namespace media {
+class AudioManagerBase;
+}  // namespace media
+
+namespace chromecast {
+namespace media {
+
+class CmaBackendFactory;
+
+// Helper class to share common logic between different AudioManager.
+class CastAudioManagerHelper {
+ public:
+  // Callback to get session ID from group ID.
+  using GetSessionIdCallback =
+      base::RepeatingCallback<std::string(const std::string&)>;
+
+  CastAudioManagerHelper(
+      ::media::AudioManagerBase* audio_manager,
+      base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
+      GetSessionIdCallback get_session_id_callback,
+      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+      mojo::PendingRemote<chromecast::mojom::ServiceConnector> connector);
+  ~CastAudioManagerHelper();
+
+  ::media::AudioManagerBase* audio_manager() { return audio_manager_; }
+
+  base::SingleThreadTaskRunner* media_task_runner() {
+    return media_task_runner_.get();
+  }
+
+  CmaBackendFactory* GetCmaBackendFactory();
+  std::string GetSessionId(const std::string& audio_group_id);
+  chromecast::mojom::ServiceConnector* GetConnector();
+
+ private:
+  ::media::AudioManagerBase* const audio_manager_;
+  base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter_;
+  GetSessionIdCallback get_session_id_callback_;
+  CmaBackendFactory* cma_backend_factory_ = nullptr;
+  scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
+
+  // |connector_| is bound to |pending_connector_| lazily on first use, as it is
+  // created on the main thread but used on the Audio thread, which may differ.
+  mojo::PendingRemote<chromecast::mojom::ServiceConnector> pending_connector_;
+  mojo::Remote<chromecast::mojom::ServiceConnector> connector_;
+
+  CastAudioManagerHelper(const CastAudioManagerHelper&) = delete;
+  CastAudioManagerHelper& operator=(const CastAudioManagerHelper&) = delete;
+};
+
+}  // namespace media
+}  // namespace chromecast
+
+#endif  // CHROMECAST_MEDIA_AUDIO_CAST_AUDIO_MANAGER_HELPER_H_

chromecast/media/audio/cast_audio_manager_unittest.cc

@@ -62,7 +62,7 @@ int OnMoreData(base::TimeDelta delay,
   return kDefaultAudioParams.frames_per_buffer();
 }
 
-std::string DummyGetSessionId(std::string /* audio_group_id */) {
+std::string DummyGetSessionId(const std::string& /* audio_group_id */) {
   return "";
 }
 
@@ -155,7 +155,7 @@ class CastAudioManagerTest : public testing::Test,
           return std::move(mock_cma_backend_);
         }));
     EXPECT_EQ(mock_backend_factory_.get(),
-              audio_manager_->cma_backend_factory());
+              audio_manager_->helper_.GetCmaBackendFactory());
   }
 
   void RunThreadsUntilIdle() {

chromecast/media/audio/cast_audio_mixer_unittest.cc

@@ -32,7 +32,7 @@ mojo::PendingRemote<chromecast::mojom::ServiceConnector> CreateConnector() {
   return connector;
 }
 
-std::string DummyGetSessionId(std::string /* audio_group_id */) {
+std::string DummyGetSessionId(const std::string& /* audio_group_id */) {
   return "";
 }
 

chromecast/media/audio/cast_audio_output_stream.cc

@@ -80,15 +80,9 @@ mixer_service::ContentType ConvertContentType(AudioContentType content_type) {
   }
 }
 
-bool IsValidDeviceId(CastAudioManager* manager, const std::string& device_id) {
-  ::media::AudioDeviceNames valid_names;
-  manager->GetAudioOutputDeviceNames(&valid_names);
-  for (const auto& v : valid_names) {
-    if (v.unique_id == device_id) {
-      return true;
-    }
-  }
-  return false;
+bool IsValidDeviceId(const std::string& device_id) {
+  return device_id == ::media::AudioDeviceDescription::kDefaultDeviceId ||
+         device_id == ::media::AudioDeviceDescription::kCommunicationsDeviceId;
 }
 
 }  // namespace
@@ -264,21 +258,19 @@ void CastAudioOutputStream::MixerServiceWrapper::FillNextBuffer(
 }
 
 CastAudioOutputStream::CastAudioOutputStream(
-    CastAudioManager* audio_manager,
-    chromecast::mojom::ServiceConnector* connector,
+    CastAudioManagerHelper* audio_manager,
     const ::media::AudioParameters& audio_params,
     const std::string& device_id_or_group_id,
     bool use_mixer_service)
     : volume_(1.0),
       audio_thread_state_(AudioOutputState::kClosed),
       audio_manager_(audio_manager),
-      connector_(connector),
+      connector_(audio_manager_->GetConnector()),
       audio_params_(audio_params),
-      device_id_(IsValidDeviceId(audio_manager, device_id_or_group_id)
+      device_id_(IsValidDeviceId(device_id_or_group_id)
                      ? device_id_or_group_id
                      : ::media::AudioDeviceDescription::kDefaultDeviceId),
-      group_id_(IsValidDeviceId(audio_manager, device_id_or_group_id)
-                    ? ""
+      group_id_(IsValidDeviceId(device_id_or_group_id) ? ""
                                                        : device_id_or_group_id),
       use_mixer_service_(use_mixer_service),
       audio_weak_factory_(this) {
@@ -354,7 +346,8 @@ void CastAudioOutputStream::Close() {
     // AudioSourceCallback::OnMoreData() will not be called anymore.
     mixer_service_wrapper_->SetRunning(false);
     POST_TO_MIXER_SERVICE_WRAPPER(
-        Close, BindToTaskRunner(audio_manager_->GetTaskRunner(),
+        Close,
+        BindToTaskRunner(audio_manager_->audio_manager()->GetTaskRunner(),
                          std::move(finish_callback)));
   } else if (cma_wrapper_) {
     // Synchronously set running to false to guarantee that
@@ -370,7 +363,7 @@ void CastAudioOutputStream::FinishClose() {
   DCHECK_CALLED_ON_VALID_THREAD(audio_thread_checker_);
   // Signal to the manager that we're closed and can be removed.
   // This should be the last call during the close process as it deletes "this".
-  audio_manager_->ReleaseOutputStream(this);
+  audio_manager_->audio_manager()->ReleaseOutputStream(this);
 }
 
 void CastAudioOutputStream::Start(AudioSourceCallback* source_callback) {
@@ -487,7 +480,7 @@ void CastAudioOutputStream::OnGetMultiroomInfo(
   if (!use_mixer_service_) {
     cma_wrapper_ = std::make_unique<CmaAudioOutputStream>(
         audio_params_, audio_params_.GetBufferDuration(), device_id_,
-        audio_manager_->cma_backend_factory());
+        audio_manager_->GetCmaBackendFactory());
     POST_TO_CMA_WRAPPER(Initialize, application_session_id,
                         std::move(multiroom_info));
   } else {

chromecast/media/audio/cast_audio_output_stream.h

@@ -26,7 +26,7 @@ namespace chromecast {
 namespace media {
 
 class CmaAudioOutputStream;
-class CastAudioManager;
+class CastAudioManagerHelper;
 
 // Chromecast implementation of AudioOutputStream.
 // This class forwards to MixerService if valid
@@ -103,8 +103,7 @@ class CastAudioOutputStream : public ::media::AudioOutputStream {
   // the |device_id_| is set to kDefaultDeviceId. Valid device_id's are either
   // ::media::AudioDeviceDescription::kDefaultDeviceId or
   // ::media::AudioDeviceDescription::kCommunicationsId.
-  CastAudioOutputStream(CastAudioManager* audio_manager,
-                        chromecast::mojom::ServiceConnector* connector,
+  CastAudioOutputStream(CastAudioManagerHelper* audio_manager,
                         const ::media::AudioParameters& audio_params,
                         const std::string& device_id_or_group_id,
                         bool use_mixer_service);
@@ -135,7 +134,7 @@ class CastAudioOutputStream : public ::media::AudioOutputStream {
 
   double volume_;
   AudioOutputState audio_thread_state_;
-  CastAudioManager* const audio_manager_;
+  CastAudioManagerHelper* const audio_manager_;
   chromecast::mojom::ServiceConnector* connector_;
   const ::media::AudioParameters audio_params_;
   // Valid |device_id_| are kDefaultDeviceId, and kCommunicationsDeviceId

chromecast/media/audio/cast_audio_output_stream_unittest.cc

@@ -43,7 +43,7 @@ using testing::NiceMock;
 
 namespace {
 
-std::string DummyGetSessionId(std::string /* audio_group_id */) {
+std::string DummyGetSessionId(const std::string& /* audio_group_id */) {
   return "AABBCCDDEE";
 }
 
@@ -299,7 +299,7 @@ class CastAudioOutputStreamTest : public ::testing::Test,
           return fake_cma_backend;
         }));
     EXPECT_EQ(mock_backend_factory_.get(),
-              audio_manager_->cma_backend_factory());
+              audio_manager_->helper_.GetCmaBackendFactory());
   }
 
   void RunThreadsUntilIdle() {

media/audio/android/audio_manager_android.cc

@@ -197,7 +197,7 @@ AudioOutputStream* AudioManagerAndroid::MakeAudioOutputStream(
     const LogCallback& log_callback) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   AudioOutputStream* stream = AudioManagerBase::MakeAudioOutputStream(
-      params, std::string(), AudioManager::LogCallback());
+      params, device_id, AudioManager::LogCallback());
   if (stream)
     streams_.insert(static_cast<MuteableAudioOutputStream*>(stream));
   return stream;
@@ -259,7 +259,6 @@ AudioOutputStream* AudioManagerAndroid::MakeLowLatencyOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
-  DLOG_IF(ERROR, !device_id.empty()) << "Not implemented!";
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
 
   if (UseAAudio()) {