Create backend factory getter for lazy creation

Internal CMA backends may need to be created lazily, because
they depend on the initialization of other internal components.

BUG=b:111465269
TEST=Build, play YT and GPMusic

Change-Id: I781b028391e35e8c21b6a3e28e5d11ad891adad3
Reviewed-on: https://chromium-review.googlesource.com/1139099
Commit-Queue: Aidan Wolter <awolter@chromium.org>
Reviewed-by: Luke Halliwell <halliwell@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Cr-Commit-Position: refs/heads/master@{#575848}

chromecast/browser/cast_content_browser_client.cc

@@ -10,6 +10,7 @@
 #include <utility>
 
 #include "base/base_switches.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/scoped_file.h"
 #include "base/i18n/rtl.h"
@@ -216,14 +217,14 @@ CastContentBrowserClient::CreateAudioManager(
 #if defined(USE_ALSA)
   return std::make_unique<media::CastAudioManagerAlsa>(
       std::make_unique<::media::AudioThreadImpl>(), audio_log_factory,
-      std::make_unique<media::CmaBackendFactoryImpl>(
-          media_pipeline_backend_manager()),
+      base::BindRepeating(&CastContentBrowserClient::GetCmaBackendFactory,
+                          base::Unretained(this)),
       GetMediaTaskRunner(), use_mixer);
 #else
   return std::make_unique<media::CastAudioManager>(
       std::make_unique<::media::AudioThreadImpl>(), audio_log_factory,
-      std::make_unique<media::CmaBackendFactoryImpl>(
-          media_pipeline_backend_manager()),
+      base::BindRepeating(&CastContentBrowserClient::GetCmaBackendFactory,
+                          base::Unretained(this)),
       GetMediaTaskRunner(), use_mixer);
 #endif  // defined(USE_ALSA)
 }

chromecast/media/audio/cast_audio_manager.cc

@@ -35,12 +35,13 @@ namespace media {
 CastAudioManager::CastAudioManager(
     std::unique_ptr<::media::AudioThread> audio_thread,
     ::media::AudioLogFactory* audio_log_factory,
-    std::unique_ptr<CmaBackendFactory> backend_factory,
+    base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
     scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner,
     bool use_mixer)
     : AudioManagerBase(std::move(audio_thread), audio_log_factory),
-      backend_factory_(std::move(backend_factory)),
+      backend_factory_getter_(std::move(backend_factory_getter)),
       backend_task_runner_(std::move(backend_task_runner)) {
+  DCHECK(backend_factory_getter_);
   if (use_mixer)
     mixer_ = std::make_unique<CastAudioMixer>(this);
 }
@@ -90,6 +91,12 @@ void CastAudioManager::ReleaseOutputStream(::media::AudioOutputStream* stream) {
   }
 }
 
+CmaBackendFactory* CastAudioManager::backend_factory() {
+  if (!backend_factory_)
+    backend_factory_ = backend_factory_getter_.Run();
+  return backend_factory_;
+}
+
 ::media::AudioOutputStream* CastAudioManager::MakeLinearOutputStream(
     const ::media::AudioParameters& params,
     const ::media::AudioManager::LogCallback& log_callback) {

chromecast/media/audio/cast_audio_manager.h

@@ -24,7 +24,7 @@ class CastAudioManager : public ::media::AudioManagerBase {
   CastAudioManager(
       std::unique_ptr<::media::AudioThread> audio_thread,
       ::media::AudioLogFactory* audio_log_factory,
-      std::unique_ptr<CmaBackendFactory> backend_factory,
+      base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
       scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner,
       bool use_mixer);
   ~CastAudioManager() override;
@@ -39,7 +39,7 @@ class CastAudioManager : public ::media::AudioManagerBase {
   const char* GetName() override;
   void ReleaseOutputStream(::media::AudioOutputStream* stream) override;
 
-  CmaBackendFactory* backend_factory() { return backend_factory_.get(); }
+  CmaBackendFactory* backend_factory();
   base::SingleThreadTaskRunner* backend_task_runner() {
     return backend_task_runner_.get();
   }
@@ -72,7 +72,8 @@ class CastAudioManager : public ::media::AudioManagerBase {
  private:
   friend class CastAudioMixer;
 
-  std::unique_ptr<CmaBackendFactory> backend_factory_;
+  base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter_;
+  CmaBackendFactory* backend_factory_ = nullptr;
   scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner_;
   std::unique_ptr<::media::AudioOutputStream> mixer_output_stream_;
   std::unique_ptr<CastAudioMixer> mixer_;

chromecast/media/audio/cast_audio_manager_alsa.cc

@@ -33,12 +33,12 @@ static const char* kInvalidAudioInputDevices[] = {
 CastAudioManagerAlsa::CastAudioManagerAlsa(
     std::unique_ptr<::media::AudioThread> audio_thread,
     ::media::AudioLogFactory* audio_log_factory,
-    std::unique_ptr<CmaBackendFactory> backend_factory,
+    base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
     scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner,
     bool use_mixer)
     : CastAudioManager(std::move(audio_thread),
                        audio_log_factory,
-                       std::move(backend_factory),
+                       std::move(backend_factory_getter),
                        backend_task_runner,
                        use_mixer),
       wrapper_(new ::media::AlsaWrapper()) {}

chromecast/media/audio/cast_audio_manager_alsa.h

@@ -25,7 +25,7 @@ class CastAudioManagerAlsa : public CastAudioManager {
   CastAudioManagerAlsa(
       std::unique_ptr<::media::AudioThread> audio_thread,
       ::media::AudioLogFactory* audio_log_factory,
-      std::unique_ptr<CmaBackendFactory> backend_factory,
+      base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
       scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner,
       bool use_mixer);
   ~CastAudioManagerAlsa() override;

chromecast/media/audio/cast_audio_manager_unittest.cc

@@ -8,6 +8,7 @@
 #include <string>
 #include <utility>
 
+#include "base/bind.h"
 #include "base/test/test_message_loop.h"
 #include "chromecast/media/cma/test/mock_cma_backend.h"
 #include "chromecast/media/cma/test/mock_cma_backend_factory.h"
@@ -36,23 +37,23 @@ class CastAudioManagerTest : public testing::Test {
   CastAudioManagerTest() : media_thread_("CastMediaThread") {
     CHECK(media_thread_.Start());
 
-    auto backend = std::make_unique<MockCmaBackendFactory>();
-    backend_factory_ = backend.get();
+    backend_factory_ = std::make_unique<MockCmaBackendFactory>();
     audio_manager_ = std::make_unique<CastAudioManager>(
         std::make_unique<::media::TestAudioThread>(), &audio_log_factory_,
-        std::move(backend), media_thread_.task_runner(), false);
+        base::BindRepeating(&CastAudioManagerTest::GetCmaBackendFactory,
+                            base::Unretained(this)),
+        media_thread_.task_runner(), false);
   }
 
   ~CastAudioManagerTest() override { audio_manager_->Shutdown(); }
+  CmaBackendFactory* GetCmaBackendFactory() { return backend_factory_.get(); }
 
  protected:
   base::TestMessageLoop message_loop_;
   base::Thread media_thread_;
   ::media::FakeAudioLogFactory audio_log_factory_;
   std::unique_ptr<CastAudioManager> audio_manager_;
-
-  // Owned by |audio_manager_|
-  MockCmaBackendFactory* backend_factory_;
+  std::unique_ptr<MockCmaBackendFactory> backend_factory_;
 };
 
 TEST_F(CastAudioManagerTest, MakeAudioOutputStreamProxy) {
@@ -68,6 +69,7 @@ TEST_F(CastAudioManagerTest, MakeAudioOutputStreamProxy) {
       .WillOnce(Invoke([&backend](const MediaPipelineDeviceParams&) {
         return std::move(backend);
       }));
+  EXPECT_EQ(backend_factory_.get(), audio_manager_->backend_factory());
 
   ::media::AudioOutputStream* stream =
       audio_manager_->MakeAudioOutputStreamProxy(kDefaultAudioParams,

chromecast/media/audio/cast_audio_mixer_unittest.cc

@@ -90,15 +90,18 @@ class MockCastAudioOutputStream : public CastAudioOutputStream {
 class MockCastAudioManager : public CastAudioManager {
  public:
   MockCastAudioManager()
-      : CastAudioManager(std::make_unique<::media::TestAudioThread>(),
-                         nullptr,
-                         nullptr,
-                         nullptr,
-                         true /* use_mixer */) {
+      : CastAudioManager(
+            std::make_unique<::media::TestAudioThread>(),
+            nullptr,
+            base::BindRepeating(&MockCastAudioManager::GetCmaBackendFactory,
+                                base::Unretained(this)),
+            nullptr,
+            true /* use_mixer */) {
     ON_CALL(*this, ReleaseOutputStream(_))
         .WillByDefault(
             Invoke(this, &MockCastAudioManager::ReleaseOutputStreamConcrete));
   }
+  media::CmaBackendFactory* GetCmaBackendFactory() { return nullptr; }
 
   MOCK_METHOD1(
       MakeMixerOutputStream,

chromecast/media/audio/cast_audio_output_stream.cc

@@ -64,12 +64,15 @@ class CastAudioOutputStream::Backend : public CmaBackend::Decoder::Delegate {
       backend_->Stop();
   }
 
-  void Open(CmaBackendFactory* backend_factory,
+  void Open(CastAudioManager* audio_manager,
             OpenCompletionCallback completion_cb) {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-    DCHECK(backend_factory);
+    DCHECK(audio_manager);
     DCHECK(backend_ == nullptr);
 
+    CmaBackendFactory* backend_factory = audio_manager->backend_factory();
+    DCHECK(backend_factory);
+
     backend_task_runner_.reset(new TaskRunnerImpl());
     MediaPipelineDeviceParams device_params(
         MediaPipelineDeviceParams::kModeIgnorePts,
@@ -289,8 +292,7 @@ bool CastAudioOutputStream::Open() {
     audio_manager_->backend_task_runner()->PostTask(
         FROM_HERE,
         base::BindOnce(
-            &Backend::Open, base::Unretained(backend_.get()),
-            audio_manager_->backend_factory(),
+            &Backend::Open, base::Unretained(backend_.get()), audio_manager_,
             base::BindOnce(&SignalWaitableEvent, &success, &completion_event)));
     completion_event.Wait();
   }

chromecast/media/audio/cast_audio_output_stream_unittest.cc

@@ -9,6 +9,7 @@
 #include <memory>
 #include <utility>
 
+#include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
@@ -201,12 +202,13 @@ class CastAudioOutputStreamTest : public ::testing::Test {
         sample_rate_(::media::AudioParameters::kAudioCDSampleRate),
         frames_per_buffer_(256) {}
   ~CastAudioOutputStreamTest() override {}
+  CmaBackendFactory* GetCmaBackendFactory() { return backend_factory_.get(); }
 
  protected:
   void SetUp() override {
     CHECK(media_thread_.Start());
-    auto backend_factory = std::make_unique<NiceMock<MockCmaBackendFactory>>();
-    ON_CALL(*backend_factory, CreateBackend(_))
+    backend_factory_ = std::make_unique<NiceMock<MockCmaBackendFactory>>();
+    ON_CALL(*backend_factory_, CreateBackend(_))
         .WillByDefault(Invoke([this](const MediaPipelineDeviceParams& params) {
           auto backend = std::make_unique<FakeCmaBackend>(params);
           media_pipeline_backend_ = backend.get();
@@ -214,7 +216,10 @@ class CastAudioOutputStreamTest : public ::testing::Test {
         }));
     audio_manager_ = std::make_unique<CastAudioManager>(
         std::make_unique<::media::TestAudioThread>(), nullptr,
-        std::move(backend_factory), media_thread_.task_runner(), false);
+        base::BindRepeating(&CastAudioOutputStreamTest::GetCmaBackendFactory,
+                            base::Unretained(this)),
+        media_thread_.task_runner(), false);
+    EXPECT_EQ(backend_factory_.get(), audio_manager_->backend_factory());
   }
 
   void TearDown() override { audio_manager_->Shutdown(); }
@@ -252,6 +257,7 @@ class CastAudioOutputStreamTest : public ::testing::Test {
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::Thread media_thread_;
   std::unique_ptr<CastAudioManager> audio_manager_;
+  std::unique_ptr<MockCmaBackendFactory> backend_factory_;
   FakeCmaBackend* media_pipeline_backend_;
   // AudioParameters used to create AudioOutputStream.
   // Tests can modify these parameters before calling CreateStream.