[Chromecast] Break dependency: chromecast/media/audio -> content

Having the content dependency creates various problems for builds and
unit tests.

Bug: internal b/111732331
Bug: internal b/112417856
Bug: internal b/112328895
Test: cast_test_lists for Android
Change-Id: I17ef19c77a8062225e9124d6eef58189dcfc504d
Reviewed-on: https://chromium-review.googlesource.com/1180426Reviewed-by: Luke Halliwell <halliwell@chromium.org>
Commit-Queue: Sean Topping <seantopping@chromium.org>
Cr-Commit-Position: refs/heads/master@{#585238}

chromecast/browser/cast_content_browser_client.cc

@@ -58,6 +58,7 @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_descriptors.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/web_preferences.h"
@@ -223,7 +224,11 @@ CastContentBrowserClient::CreateAudioManager(
       std::make_unique<::media::AudioThreadImpl>(), audio_log_factory,
       base::BindRepeating(&CastContentBrowserClient::GetCmaBackendFactory,
                           base::Unretained(this)),
-      GetMediaTaskRunner(), use_mixer);
+      content::BrowserThread::GetTaskRunnerForThread(
+          content::BrowserThread::UI),
+      GetMediaTaskRunner(),
+      content::ServiceManagerConnection::GetForProcess()->GetConnector(),
+      use_mixer);
 #else
   return std::make_unique<media::CastAudioManager>(
       std::make_unique<::media::AudioThreadImpl>(), audio_log_factory,
@@ -231,7 +236,9 @@ CastContentBrowserClient::CreateAudioManager(
                           base::Unretained(this)),
       content::BrowserThread::GetTaskRunnerForThread(
           content::BrowserThread::UI),
-      GetMediaTaskRunner(), use_mixer);
+      GetMediaTaskRunner(),
+      content::ServiceManagerConnection::GetForProcess()->GetConnector(),
+      use_mixer);
 #endif  // defined(USE_ALSA)
 }
 

chromecast/media/audio/BUILD.gn

@@ -23,7 +23,6 @@ cast_source_set("audio") {
     "//chromecast/media/cma/backend",
     "//chromecast/media/cma/base",
     "//chromecast/public/media",
-    "//content/public/common",
     "//media",
     "//media:shared_memory_support",
     "//services/service_manager/public/cpp",

chromecast/media/audio/cast_audio_manager.cc

@@ -38,12 +38,15 @@ CastAudioManager::CastAudioManager(
     base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
     scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner,
+    service_manager::Connector* connector,
     bool use_mixer)
     : AudioManagerBase(std::move(audio_thread), audio_log_factory),
       backend_factory_getter_(std::move(backend_factory_getter)),
       browser_task_runner_(std::move(browser_task_runner)),
-      backend_task_runner_(std::move(backend_task_runner)) {
+      backend_task_runner_(std::move(backend_task_runner)),
+      browser_connector_(connector) {
   DCHECK(backend_factory_getter_);
+  DCHECK(browser_connector_);
   if (use_mixer)
     mixer_ = std::make_unique<CastAudioMixer>(this);
 }
@@ -177,10 +180,5 @@ CmaBackendFactory* CastAudioManager::backend_factory() {
   return mixer_output_stream_.get();
 }
 
-void CastAudioManager::SetBrowserConnectorForTesting(
-    service_manager::Connector* browser_connector) {
-  browser_connector_ = browser_connector;
-}
-
 }  // namespace media
 }  // namespace chromecast

chromecast/media/audio/cast_audio_manager.h

@@ -28,6 +28,7 @@ class CastAudioManager : public ::media::AudioManagerBase {
       base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
       scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner,
+      service_manager::Connector* connector,
       bool use_mixer);
   ~CastAudioManager() override;
 
@@ -46,9 +47,6 @@ class CastAudioManager : public ::media::AudioManagerBase {
     return backend_task_runner_.get();
   }
 
-  void SetBrowserConnectorForTesting(
-      service_manager::Connector* browser_connector);
-
  protected:
   // AudioManagerBase implementation.
   ::media::AudioOutputStream* MakeLinearOutputStream(
@@ -81,11 +79,10 @@ class CastAudioManager : public ::media::AudioManagerBase {
   CmaBackendFactory* backend_factory_ = nullptr;
   scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner_;
+  service_manager::Connector* const browser_connector_;
   std::unique_ptr<::media::AudioOutputStream> mixer_output_stream_;
   std::unique_ptr<CastAudioMixer> mixer_;
 
-  // Used in tests to override the default browser connector.
-  service_manager::Connector* browser_connector_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(CastAudioManager);
 };

chromecast/media/audio/cast_audio_manager_alsa.cc

@@ -9,7 +9,6 @@
 
 #include "base/memory/free_deleter.h"
 #include "chromecast/media/cma/backend/cma_backend_factory.h"
-#include "content/public/browser/browser_thread.h"
 #include "media/audio/alsa/alsa_input.h"
 #include "media/audio/alsa/alsa_wrapper.h"
 
@@ -35,14 +34,16 @@ CastAudioManagerAlsa::CastAudioManagerAlsa(
     std::unique_ptr<::media::AudioThread> audio_thread,
     ::media::AudioLogFactory* audio_log_factory,
     base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter,
+    scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner,
+    service_manager::Connector* connector,
     bool use_mixer)
     : CastAudioManager(std::move(audio_thread),
                        audio_log_factory,
                        std::move(backend_factory_getter),
-                       content::BrowserThread::GetTaskRunnerForThread(
-                           content::BrowserThread::UI),
+                       browser_task_runner,
                        backend_task_runner,
+                       connector,
                        use_mixer),
       wrapper_(new ::media::AlsaWrapper()) {}
 

chromecast/media/audio/cast_audio_manager_alsa.h

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

chromecast/media/audio/cast_audio_manager_alsa_unittest.cc

@@ -9,9 +9,11 @@
 
 #include "base/bind.h"
 #include "base/test/test_message_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "chromecast/media/cma/test/mock_cma_backend_factory.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/test_audio_thread.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
@@ -28,9 +30,15 @@ const ::media::AudioParameters kDefaultAudioParams(
 
 void OnLogMessage(const std::string& message) {}
 
+std::unique_ptr<service_manager::Connector> CreateConnector() {
+  service_manager::mojom::ConnectorRequest request;
+  return service_manager::Connector::Create(&request);
+}
+
 class CastAudioManagerAlsaTest : public testing::Test {
  public:
-  CastAudioManagerAlsaTest() : media_thread_("CastMediaThread") {
+  CastAudioManagerAlsaTest()
+      : media_thread_("CastMediaThread"), connector_(CreateConnector()) {
     CHECK(media_thread_.Start());
 
     backend_factory_ = std::make_unique<MockCmaBackendFactory>();
@@ -38,7 +46,8 @@ class CastAudioManagerAlsaTest : public testing::Test {
         std::make_unique<::media::TestAudioThread>(), &audio_log_factory_,
         base::BindRepeating(&CastAudioManagerAlsaTest::GetCmaBackendFactory,
                             base::Unretained(this)),
-        media_thread_.task_runner(), false);
+        base::ThreadTaskRunnerHandle::Get(), media_thread_.task_runner(),
+        connector_.get(), false);
   }
 
   ~CastAudioManagerAlsaTest() override { audio_manager_->Shutdown(); }
@@ -48,6 +57,7 @@ class CastAudioManagerAlsaTest : public testing::Test {
   base::TestMessageLoop message_loop_;
   std::unique_ptr<MockCmaBackendFactory> backend_factory_;
   base::Thread media_thread_;
+  std::unique_ptr<service_manager::Connector> connector_;
   ::media::FakeAudioLogFactory audio_log_factory_;
   std::unique_ptr<CastAudioManagerAlsa> audio_manager_;
 };

chromecast/media/audio/cast_audio_manager_unittest.cc

@@ -65,8 +65,7 @@ class CastAudioManagerTest : public testing::Test {
         base::BindRepeating(&CastAudioManagerTest::GetCmaBackendFactory,
                             base::Unretained(this)),
         scoped_task_environment_.GetMainThreadTaskRunner(),
-        media_thread_.task_runner(), false);
-    audio_manager_->SetBrowserConnectorForTesting(connector_.get());
+        media_thread_.task_runner(), connector_.get(), false);
   }
 
   ~CastAudioManagerTest() override { audio_manager_->Shutdown(); }

chromecast/media/audio/cast_audio_mixer_unittest.cc

@@ -17,6 +17,7 @@
 #include "chromecast/media/audio/cast_audio_manager.h"
 #include "chromecast/media/audio/cast_audio_output_stream.h"
 #include "chromecast/media/cma/backend/cma_backend_factory.h"
+#include "media/audio/audio_io.h"
 #include "media/audio/test_audio_thread.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -33,6 +34,11 @@ using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
+std::unique_ptr<service_manager::Connector> CreateConnector() {
+  service_manager::mojom::ConnectorRequest request;
+  return service_manager::Connector::Create(&request);
+}
+
 // Utility functions
 ::media::AudioParameters GetAudioParams() {
   return ::media::AudioParameters(
@@ -40,6 +46,20 @@ using testing::StrictMock;
       ::media::CHANNEL_LAYOUT_STEREO, 48000, 1024);
 }
 
+void SignalPull(
+    ::media::AudioOutputStream::AudioSourceCallback* source_callback,
+    base::TimeDelta delay) {
+  std::unique_ptr<::media::AudioBus> audio_bus =
+      ::media::AudioBus::Create(GetAudioParams());
+  source_callback->OnMoreData(delay, base::TimeTicks::Now(), 0,
+                              audio_bus.get());
+}
+
+void SignalError(
+    ::media::AudioOutputStream::AudioSourceCallback* source_callback) {
+  source_callback->OnError();
+}
+
 // Mock implementations
 class MockAudioSourceCallback
     : public ::media::AudioOutputStream::AudioSourceCallback {
@@ -63,17 +83,9 @@ class MockAudioSourceCallback
   }
 };
 
-class MockCastAudioOutputStream : public CastAudioOutputStream {
+class MockMediaAudioOutputStream : public ::media::AudioOutputStream {
  public:
-  MockCastAudioOutputStream(
-      const ::media::AudioParameters& audio_params,
-      scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
-      service_manager::Connector* browser_connector,
-      CastAudioManager* audio_manager)
-      : CastAudioOutputStream(audio_params,
-                              browser_task_runner,
-                              browser_connector,
-                              audio_manager) {}
+  MockMediaAudioOutputStream() {}
 
   MOCK_METHOD0(Open, bool());
   MOCK_METHOD0(Close, void());
@@ -81,22 +93,11 @@ class MockCastAudioOutputStream : public CastAudioOutputStream {
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD1(SetVolume, void(double volume));
   MOCK_METHOD1(GetVolume, void(double* volume));
-
-  void SignalPull(AudioSourceCallback* source_callback, base::TimeDelta delay) {
-    std::unique_ptr<::media::AudioBus> audio_bus =
-        ::media::AudioBus::Create(GetAudioParams());
-    source_callback->OnMoreData(delay, base::TimeTicks::Now(), 0,
-                                audio_bus.get());
-  }
-
-  void SignalError(AudioSourceCallback* source_callback) {
-    source_callback->OnError();
-  }
 };
 
 class MockCastAudioManager : public CastAudioManager {
  public:
-  MockCastAudioManager()
+  explicit MockCastAudioManager(service_manager::Connector* connector)
       : CastAudioManager(
             std::make_unique<::media::TestAudioThread>(),
             nullptr,
@@ -104,6 +105,7 @@ class MockCastAudioManager : public CastAudioManager {
                                 base::Unretained(this)),
             nullptr,
             nullptr,
+            connector,
             true /* use_mixer */) {
     ON_CALL(*this, ReleaseOutputStream(_))
         .WillByDefault(
@@ -128,15 +130,14 @@ class CastAudioMixerTest : public ::testing::Test {
   CastAudioMixerTest()
       : scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        connector_(CreateConnector()),
         source_callback_(nullptr) {}
   ~CastAudioMixerTest() override {}
 
  protected:
   void SetUp() override {
-    mock_manager_.reset(new StrictMock<MockCastAudioManager>());
-    mock_mixer_stream_.reset(new StrictMock<MockCastAudioOutputStream>(
-        GetAudioParams(), scoped_task_environment_.GetMainThreadTaskRunner(),
-        nullptr, mock_manager_.get()));
+    mock_manager_.reset(new StrictMock<MockCastAudioManager>(connector_.get()));
+    mock_mixer_stream_.reset(new StrictMock<MockMediaAudioOutputStream>());
 
     ON_CALL(*mock_manager_, MakeMixerOutputStream(_))
         .WillByDefault(Return(mock_mixer_stream_.get()));
@@ -149,7 +150,9 @@ class CastAudioMixerTest : public ::testing::Test {
   void TearDown() override { mock_manager_->Shutdown(); }
 
   MockCastAudioManager& mock_manager() { return *mock_manager_; }
-  MockCastAudioOutputStream& mock_mixer_stream() { return *mock_mixer_stream_; }
+  MockMediaAudioOutputStream& mock_mixer_stream() {
+    return *mock_mixer_stream_;
+  }
 
   ::media::AudioOutputStream* CreateMixerStream() {
     return mock_manager_->MakeAudioOutputStream(
@@ -157,8 +160,9 @@ class CastAudioMixerTest : public ::testing::Test {
   }
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
+  std::unique_ptr<service_manager::Connector> connector_;
   std::unique_ptr<MockCastAudioManager> mock_manager_;
-  std::unique_ptr<MockCastAudioOutputStream> mock_mixer_stream_;
+  std::unique_ptr<MockMediaAudioOutputStream> mock_mixer_stream_;
 
   // Saved params passed to |mock_mixer_stream_|.
   ::media::AudioOutputStream::AudioSourceCallback* source_callback_;
@@ -287,7 +291,7 @@ TEST_F(CastAudioMixerTest, MultiStreamCycle) {
 
     for (auto& source : sources)
       EXPECT_CALL(*source, OnMoreData(_, _, _, _));
-    mock_mixer_stream().SignalPull(source_callback_, base::TimeDelta());
+    SignalPull(source_callback_, base::TimeDelta());
 
     EXPECT_CALL(mock_manager(), ReleaseOutputStream(stream));
     stream->Close();
@@ -350,7 +354,7 @@ TEST_F(CastAudioMixerTest, OnError) {
   // Note that error will only be triggered on the first stream because that
   // is the only stream that has been started.
   EXPECT_CALL(source, OnError());
-  mock_mixer_stream().SignalError(source_callback_);
+  SignalError(source_callback_);
   base::RunLoop().RunUntilIdle();
 
   // Try to add another stream.
@@ -398,7 +402,7 @@ TEST_F(CastAudioMixerTest, Delay) {
   // using the same AudioParameters.
   base::TimeDelta delay = base::TimeDelta::FromMicroseconds(1000);
   EXPECT_CALL(source, OnMoreData(delay, _, 0, _));
-  mock_mixer_stream().SignalPull(source_callback_, delay);
+  SignalPull(source_callback_, delay);
 
   EXPECT_CALL(mock_mixer_stream(), Stop());
   EXPECT_CALL(mock_mixer_stream(), Close());

chromecast/media/audio/cast_audio_output_stream.cc

@@ -26,7 +26,6 @@
 #include "chromecast/public/media/decoder_config.h"
 #include "chromecast/public/media/media_pipeline_device_params.h"
 #include "chromecast/public/volume_control.h"
-#include "content/public/common/service_manager_connection.h"
 #include "media/audio/audio_device_description.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/decoder_buffer.h"
@@ -359,6 +358,7 @@ CastAudioOutputStream::CastAudioOutputStream(
       audio_manager_(audio_manager),
       volume_(1.0) {
   DCHECK(browser_task_runner_);
+  DCHECK(browser_connector_);
   VLOG(1) << "CastAudioOutputStream " << this << " created with "
           << audio_params_.AsHumanReadableString();
 }
@@ -477,10 +477,6 @@ void CastAudioOutputStream::BindConnectorRequest(
 
 void CastAudioOutputStream::BindConnectorRequestOnBrowserTaskRunner(
     service_manager::mojom::ConnectorRequest connector_request) {
-  if (!browser_connector_) {
-    browser_connector_ =
-        content::ServiceManagerConnection::GetForProcess()->GetConnector();
-  }
   browser_connector_->BindConnectorRequest(std::move(connector_request));
 }
 

chromecast/media/audio/cast_audio_output_stream_unittest.cc

@@ -250,8 +250,7 @@ class CastAudioOutputStreamTest : public ::testing::Test {
         base::BindRepeating(&CastAudioOutputStreamTest::GetCmaBackendFactory,
                             base::Unretained(this)),
         scoped_task_environment_.GetMainThreadTaskRunner(),
-        media_thread_.task_runner(), false);
-    audio_manager_->SetBrowserConnectorForTesting(connector_.get());
+        media_thread_.task_runner(), connector_.get(), false);
     EXPECT_EQ(backend_factory_.get(), audio_manager_->backend_factory());
   }