Fetch and apply Multiroom info in CAOS

CastAudioOutputStream can now use internal backends with multizone. In
order for multizone to work, we first need to retrieve the multiroom
info and pass it to the backend.

BUG=b:111694183
TEST=Build, cast_media_unittests

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

chromecast/browser/cast_content_browser_client.cc

@@ -230,6 +230,8 @@ CastContentBrowserClient::CreateAudioManager(
       std::make_unique<::media::AudioThreadImpl>(), audio_log_factory,
       base::BindRepeating(&CastContentBrowserClient::GetCmaBackendFactory,
                           base::Unretained(this)),
+      content::BrowserThread::GetTaskRunnerForThread(
+          content::BrowserThread::UI),
       GetMediaTaskRunner(), use_mixer);
 #endif  // defined(USE_ALSA)
 }

chromecast/media/BUILD.gn

@@ -63,9 +63,14 @@ test("cast_media_unittests") {
     "//base/test:test_support",
     "//chromecast/base",
     "//chromecast/base/metrics:test_support",
+    "//chromecast/common/mojom",
     "//chromecast/media/cma:test_support",
     "//chromecast/public",
+    "//content/test:test_support",
     "//media:test_support",
+    "//media/mojo:test_support",
+    "//mojo/core/embedder",
+    "//services/service_manager/public/cpp",
     "//testing/gmock",
     "//testing/gtest",
   ]

chromecast/media/DEPS

 include_rules = [
+  "+chromecast/common/mojom",
+  "+content/public/browser/browser_thread.h",
+  "+content/public/common/service_manager_connection.h",
+  "+content/public/test/test_browser_thread.h",
+  "+content/public/test/test_browser_thread_bundle.h",
+  "+content/public/test/test_utils.h",
   "+crypto",
   "+media/audio",
   "+media/base",
   "+media/cdm",
+  "+mojo/core/embedder/embedder.h",
+  "+mojo/public/cpp/bindings/binding.h",
   "+ui/gfx/geometry",
   "+ui/gfx/overlay_transform.h",
+  "+services/service_manager/public",
 ]

chromecast/media/audio/BUILD.gn

@@ -15,24 +15,28 @@ cast_source_set("audio") {
     "cast_audio_output_stream.h",
   ]
 
-  if (use_alsa) {
-    sources += [
-      "cast_audio_manager_alsa.cc",
-      "cast_audio_manager_alsa.h",
-    ]
-  }
-
   deps = [
     "//base",
     "//chromecast/base",
+    "//chromecast/common/mojom",
     "//chromecast/media/base",
     "//chromecast/media/cma/backend",
     "//chromecast/media/cma/base",
     "//chromecast/public/media",
+    "//content/public/common",
     "//media",
     "//media:shared_memory_support",
+    "//services/service_manager/public/cpp",
   ]
 
+  if (use_alsa) {
+    sources += [
+      "cast_audio_manager_alsa.cc",
+      "cast_audio_manager_alsa.h",
+    ]
+    deps += [ "//content/public/browser" ]
+  }
+
   configs += [ "//media/audio:platform_config" ]
 }
 

chromecast/media/audio/cast_audio_manager.cc

@@ -36,10 +36,12 @@ CastAudioManager::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,
     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)) {
   DCHECK(backend_factory_getter_);
   if (use_mixer)
@@ -106,7 +108,8 @@ CmaBackendFactory* CastAudioManager::backend_factory() {
   if (mixer_)
     return mixer_->MakeStream(params);
   else
-    return new CastAudioOutputStream(params, this);
+    return new CastAudioOutputStream(params, browser_task_runner_,
+                                     browser_connector_, this);
 }
 
 ::media::AudioOutputStream* CastAudioManager::MakeLowLatencyOutputStream(
@@ -119,7 +122,8 @@ CmaBackendFactory* CastAudioManager::backend_factory() {
   if (mixer_)
     return mixer_->MakeStream(params);
   else
-    return new CastAudioOutputStream(params, this);
+    return new CastAudioOutputStream(params, browser_task_runner_,
+                                     browser_connector_, this);
 }
 
 ::media::AudioInputStream* CastAudioManager::MakeLinearInputStream(
@@ -168,9 +172,15 @@ CmaBackendFactory* CastAudioManager::backend_factory() {
 
   // Keep a reference to this stream for proper behavior on
   // CastAudioManager::ReleaseOutputStream.
-  mixer_output_stream_.reset(new CastAudioOutputStream(params, this));
+  mixer_output_stream_.reset(new CastAudioOutputStream(
+      params, browser_task_runner_, browser_connector_, this));
   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

@@ -11,6 +11,7 @@
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "media/audio/audio_manager_base.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace chromecast {
 
@@ -25,6 +26,7 @@ class CastAudioManager : public ::media::AudioManagerBase {
       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,
       bool use_mixer);
   ~CastAudioManager() override;
@@ -44,6 +46,9 @@ class CastAudioManager : public ::media::AudioManagerBase {
     return backend_task_runner_.get();
   }
 
+  void SetBrowserConnectorForTesting(
+      service_manager::Connector* browser_connector);
+
  protected:
   // AudioManagerBase implementation.
   ::media::AudioOutputStream* MakeLinearOutputStream(
@@ -74,9 +79,14 @@ class CastAudioManager : public ::media::AudioManagerBase {
 
   base::RepeatingCallback<CmaBackendFactory*()> backend_factory_getter_;
   CmaBackendFactory* backend_factory_ = nullptr;
+  scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner_;
   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,6 +9,7 @@
 
 #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"
 
@@ -39,6 +40,8 @@ CastAudioManagerAlsa::CastAudioManagerAlsa(
     : CastAudioManager(std::move(audio_thread),
                        audio_log_factory,
                        std::move(backend_factory_getter),
+                       content::BrowserThread::GetTaskRunnerForThread(
+                           content::BrowserThread::UI),
                        backend_task_runner,
                        use_mixer),
       wrapper_(new ::media::AlsaWrapper()) {}

chromecast/media/audio/cast_audio_manager_unittest.cc

@@ -9,11 +9,15 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/test/test_message_loop.h"
+#include "base/test/scoped_task_environment.h"
+#include "chromecast/common/mojom/multiroom.mojom.h"
+#include "chromecast/media/audio/cast_audio_output_stream.h"
 #include "chromecast/media/cma/test/mock_cma_backend.h"
 #include "chromecast/media/cma/test/mock_cma_backend_factory.h"
+#include "chromecast/media/cma/test/mock_multiroom_manager.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/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -22,6 +26,15 @@ using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
 
+namespace {
+constexpr char kChromecastServiceName[] = "chromecast";
+
+std::unique_ptr<service_manager::Connector> CreateConnector() {
+  service_manager::mojom::ConnectorRequest request;
+  return service_manager::Connector::Create(&request);
+}
+}  // namespace
+
 namespace chromecast {
 namespace media {
 namespace {
@@ -34,26 +47,53 @@ const ::media::AudioParameters kDefaultAudioParams(
 
 class CastAudioManagerTest : public testing::Test {
  public:
-  CastAudioManagerTest() : media_thread_("CastMediaThread") {
+  CastAudioManagerTest()
+      : media_thread_("CastMediaThread"), connector_(CreateConnector()) {
     CHECK(media_thread_.Start());
 
+    // Set the test connector to override interface bindings.
+    service_manager::Connector::TestApi connector_test_api(connector_.get());
+    connector_test_api.OverrideBinderForTesting(
+        service_manager::Identity(kChromecastServiceName),
+        mojom::MultiroomManager::Name_,
+        base::BindRepeating(&CastAudioManagerTest::BindMultiroomManager,
+                            base::Unretained(this)));
+
     backend_factory_ = std::make_unique<MockCmaBackendFactory>();
     audio_manager_ = std::make_unique<CastAudioManager>(
         std::make_unique<::media::TestAudioThread>(), &audio_log_factory_,
         base::BindRepeating(&CastAudioManagerTest::GetCmaBackendFactory,
                             base::Unretained(this)),
+        scoped_task_environment_.GetMainThreadTaskRunner(),
         media_thread_.task_runner(), false);
+    audio_manager_->SetBrowserConnectorForTesting(connector_.get());
   }
 
   ~CastAudioManagerTest() override { audio_manager_->Shutdown(); }
   CmaBackendFactory* GetCmaBackendFactory() { return backend_factory_.get(); }
 
+  // Binds |multiroom_manager_| to the interface requested through the test
+  // connector.
+  void BindMultiroomManager(mojo::ScopedMessagePipeHandle handle) {
+    multiroom_manager_.Bind(std::move(handle));
+  }
+
  protected:
-  base::TestMessageLoop message_loop_;
+  bool OpenStream(::media::AudioOutputStream* stream) {
+    bool success = stream->Open();
+    media_thread_.FlushForTesting();
+    scoped_task_environment_.RunUntilIdle();
+    media_thread_.FlushForTesting();
+    return success;
+  }
+
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::Thread media_thread_;
   ::media::FakeAudioLogFactory audio_log_factory_;
   std::unique_ptr<CastAudioManager> audio_manager_;
   std::unique_ptr<MockCmaBackendFactory> backend_factory_;
+  std::unique_ptr<service_manager::Connector> connector_;
+  MockMultiroomManager multiroom_manager_;
 };
 
 TEST_F(CastAudioManagerTest, MakeAudioOutputStreamProxy) {
@@ -74,7 +114,7 @@ TEST_F(CastAudioManagerTest, MakeAudioOutputStreamProxy) {
   ::media::AudioOutputStream* stream =
       audio_manager_->MakeAudioOutputStreamProxy(kDefaultAudioParams,
                                                  std::string());
-  EXPECT_TRUE(stream->Open());
+  EXPECT_TRUE(OpenStream(stream));
   stream->Close();
 }
 

chromecast/media/audio/cast_audio_mixer_unittest.cc

@@ -11,13 +11,14 @@
 #include <vector>
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/time/time.h"
 #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/test_audio_thread.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -64,9 +65,15 @@ class MockAudioSourceCallback
 
 class MockCastAudioOutputStream : public CastAudioOutputStream {
  public:
-  MockCastAudioOutputStream(const ::media::AudioParameters& audio_params,
-                            CastAudioManager* audio_manager)
-      : CastAudioOutputStream(audio_params, audio_manager) {}
+  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) {}
 
   MOCK_METHOD0(Open, bool());
   MOCK_METHOD0(Close, void());
@@ -96,6 +103,7 @@ class MockCastAudioManager : public CastAudioManager {
             base::BindRepeating(&MockCastAudioManager::GetCmaBackendFactory,
                                 base::Unretained(this)),
             nullptr,
+            nullptr,
             true /* use_mixer */) {
     ON_CALL(*this, ReleaseOutputStream(_))
         .WillByDefault(
@@ -117,14 +125,18 @@ class MockCastAudioManager : public CastAudioManager {
 // Generates StrictMocks of Mixer, Manager, and Mixer OutputStream.
 class CastAudioMixerTest : public ::testing::Test {
  public:
-  CastAudioMixerTest() : source_callback_(nullptr) {}
+  CastAudioMixerTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        source_callback_(nullptr) {}
   ~CastAudioMixerTest() override {}
 
  protected:
   void SetUp() override {
     mock_manager_.reset(new StrictMock<MockCastAudioManager>());
     mock_mixer_stream_.reset(new StrictMock<MockCastAudioOutputStream>(
-        GetAudioParams(), mock_manager_.get()));
+        GetAudioParams(), scoped_task_environment_.GetMainThreadTaskRunner(),
+        nullptr, mock_manager_.get()));
 
     ON_CALL(*mock_manager_, MakeMixerOutputStream(_))
         .WillByDefault(Return(mock_mixer_stream_.get()));
@@ -144,7 +156,7 @@ class CastAudioMixerTest : public ::testing::Test {
         GetAudioParams(), "", ::media::AudioManager::LogCallback());
   }
 
-  base::MessageLoop message_loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   std::unique_ptr<MockCastAudioManager> mock_manager_;
   std::unique_ptr<MockCastAudioOutputStream> mock_mixer_stream_;
 

chromecast/media/audio/cast_audio_output_stream.h

@@ -8,8 +8,10 @@
 #include <memory>
 
 #include "base/macros.h"
+#include "base/single_thread_task_runner.h"
 #include "media/audio/audio_io.h"
 #include "media/base/audio_parameters.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace chromecast {
 namespace media {
@@ -18,8 +20,13 @@ class CastAudioManager;
 
 class CastAudioOutputStream : public ::media::AudioOutputStream {
  public:
-  CastAudioOutputStream(const ::media::AudioParameters& audio_params,
-                        CastAudioManager* audio_manager);
+  CastAudioOutputStream(
+      const ::media::AudioParameters& audio_params,
+      scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner,
+      // If the |browser_connector| is nullptr, then it will be fetched from the
+      // BrowserThread before usage.
+      service_manager::Connector* browser_connector,
+      CastAudioManager* audio_manager);
   ~CastAudioOutputStream() override;
 
   // ::media::AudioOutputStream implementation.
@@ -30,10 +37,17 @@ class CastAudioOutputStream : public ::media::AudioOutputStream {
   void SetVolume(double volume) override;
   void GetVolume(double* volume) override;
 
+  void BindConnectorRequest(
+      service_manager::mojom::ConnectorRequest connector_request);
+
  private:
   class Backend;
+  void BindConnectorRequestOnBrowserTaskRunner(
+      service_manager::mojom::ConnectorRequest connector_request);
 
   const ::media::AudioParameters audio_params_;
+  scoped_refptr<base::SingleThreadTaskRunner> browser_task_runner_;
+  service_manager::Connector* browser_connector_ = nullptr;
   CastAudioManager* const audio_manager_;
   double volume_;
 

chromecast/media/audio/cast_audio_output_stream_unittest.cc

@@ -14,14 +14,20 @@
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/time/time.h"
+#include "chromecast/common/mojom/multiroom.mojom.h"
 #include "chromecast/media/audio/cast_audio_manager.h"
 #include "chromecast/media/audio/cast_audio_mixer.h"
 #include "chromecast/media/cma/backend/cma_backend.h"
 #include "chromecast/media/cma/base/decoder_buffer_base.h"
 #include "chromecast/media/cma/test/mock_cma_backend_factory.h"
+#include "chromecast/media/cma/test/mock_multiroom_manager.h"
 #include "chromecast/public/task_runner.h"
+#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "media/audio/mock_audio_source_callback.h"
 #include "media/audio/test_audio_thread.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -35,6 +41,12 @@ namespace {
 const char kDefaultDeviceId[] = "";
 const int64_t kDelayUs = 123;
 const int64_t kDelayTimestampUs = 123456789;
+constexpr char kChromecastServiceName[] = "chromecast";
+
+std::unique_ptr<service_manager::Connector> CreateConnector() {
+  service_manager::mojom::ConnectorRequest request;
+  return service_manager::Connector::Create(&request);
+}
 
 int OnMoreData(base::TimeDelta /* delay */,
                base::TimeTicks /* delay_timestamp */,
@@ -200,10 +212,26 @@ class CastAudioOutputStreamTest : public ::testing::Test {
         format_(::media::AudioParameters::AUDIO_PCM_LINEAR),
         channel_layout_(::media::CHANNEL_LAYOUT_MONO),
         sample_rate_(::media::AudioParameters::kAudioCDSampleRate),
-        frames_per_buffer_(256) {}
+        frames_per_buffer_(256),
+        connector_(CreateConnector()) {
+    // Set the test connector to override interface bindings.
+    service_manager::Connector::TestApi connector_test_api(connector_.get());
+    connector_test_api.OverrideBinderForTesting(
+        service_manager::Identity(kChromecastServiceName),
+        mojom::MultiroomManager::Name_,
+        base::BindRepeating(&CastAudioOutputStreamTest::BindMultiroomManager,
+                            base::Unretained(this)));
+  }
   ~CastAudioOutputStreamTest() override {}
+
   CmaBackendFactory* GetCmaBackendFactory() { return backend_factory_.get(); }
 
+  // Binds |multiroom_manager_| to the interface requested through the test
+  // connector.
+  void BindMultiroomManager(mojo::ScopedMessagePipeHandle handle) {
+    multiroom_manager_.Bind(std::move(handle));
+  }
+
  protected:
   void SetUp() override {
     CHECK(media_thread_.Start());
@@ -218,7 +246,9 @@ class CastAudioOutputStreamTest : public ::testing::Test {
         std::make_unique<::media::TestAudioThread>(), nullptr,
         base::BindRepeating(&CastAudioOutputStreamTest::GetCmaBackendFactory,
                             base::Unretained(this)),
+        scoped_task_environment_.GetMainThreadTaskRunner(),
         media_thread_.task_runner(), false);
+    audio_manager_->SetBrowserConnectorForTesting(connector_.get());
     EXPECT_EQ(backend_factory_.get(), audio_manager_->backend_factory());
   }
 
@@ -242,6 +272,17 @@ class CastAudioOutputStreamTest : public ::testing::Test {
         ::media::AudioManager::LogCallback());
   }
 
+  bool OpenStream(::media::AudioOutputStream* stream) {
+    bool success = stream->Open();
+    // TODO(awolter) Determine a better way to ensure that all the tasks are
+    // flushed.
+    media_thread_.FlushForTesting();
+    scoped_task_environment_.RunUntilIdle();
+    media_thread_.FlushForTesting();
+    media_thread_.FlushForTesting();
+    return success;
+  }
+
   // Runs the messsage loop for duration equivalent to the given number of
   // audio |frames|.
   void RunMessageLoopFor(int frames) {
@@ -265,6 +306,8 @@ class CastAudioOutputStreamTest : public ::testing::Test {
   ::media::ChannelLayout channel_layout_;
   int sample_rate_;
   int frames_per_buffer_;
+  std::unique_ptr<service_manager::Connector> connector_;
+  MockMultiroomManager multiroom_manager_;
 };
 
 TEST_F(CastAudioOutputStreamTest, Format) {
@@ -275,7 +318,7 @@ TEST_F(CastAudioOutputStreamTest, Format) {
     format_ = format[i];
     ::media::AudioOutputStream* stream = CreateStream();
     ASSERT_TRUE(stream);
-    EXPECT_TRUE(stream->Open());
+    EXPECT_TRUE(OpenStream(stream));
 
     FakeAudioDecoder* audio_decoder = GetAudio();
     ASSERT_TRUE(audio_decoder);
@@ -295,7 +338,7 @@ TEST_F(CastAudioOutputStreamTest, ChannelLayout) {
     channel_layout_ = layout[i];
     ::media::AudioOutputStream* stream = CreateStream();
     ASSERT_TRUE(stream);
-    EXPECT_TRUE(stream->Open());
+    EXPECT_TRUE(OpenStream(stream));
 
     FakeAudioDecoder* audio_decoder = GetAudio();
     ASSERT_TRUE(audio_decoder);
@@ -311,7 +354,7 @@ TEST_F(CastAudioOutputStreamTest, SampleRate) {
   sample_rate_ = ::media::AudioParameters::kAudioCDSampleRate;
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(stream->Open());
+  EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
@@ -325,7 +368,7 @@ TEST_F(CastAudioOutputStreamTest, DeviceState) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
 
-  EXPECT_TRUE(stream->Open());
+  EXPECT_TRUE(OpenStream(stream));
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   FakeCmaBackend* backend = GetBackend();
@@ -349,7 +392,7 @@ TEST_F(CastAudioOutputStreamTest, DeviceState) {
 TEST_F(CastAudioOutputStreamTest, PushFrame) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(stream->Open());
+  EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
@@ -386,7 +429,7 @@ TEST_F(CastAudioOutputStreamTest, PushFrame) {
 TEST_F(CastAudioOutputStreamTest, DeviceBusy) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(stream->Open());
+  EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
@@ -419,7 +462,7 @@ TEST_F(CastAudioOutputStreamTest, DeviceBusy) {
 TEST_F(CastAudioOutputStreamTest, DeviceError) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(stream->Open());
+  EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
@@ -442,7 +485,7 @@ TEST_F(CastAudioOutputStreamTest, DeviceError) {
 TEST_F(CastAudioOutputStreamTest, DeviceAsyncError) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(stream->Open());
+  EXPECT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
@@ -453,7 +496,7 @@ TEST_F(CastAudioOutputStreamTest, DeviceAsyncError) {
   EXPECT_CALL(source_callback, OnMoreData(_, _, _, _))
       .WillRepeatedly(Invoke(OnMoreData));
   // AudioOutputStream must report error to source callback.
-  EXPECT_CALL(source_callback, OnError());
+  EXPECT_CALL(source_callback, OnError()).Times(testing::AtLeast(1));
   stream->Start(&source_callback);
   RunMessageLoopFor(5);
 
@@ -467,7 +510,7 @@ TEST_F(CastAudioOutputStreamTest, DeviceAsyncError) {
 TEST_F(CastAudioOutputStreamTest, Volume) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  ASSERT_TRUE(stream->Open());
+  ASSERT_TRUE(OpenStream(stream));
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
 
@@ -488,7 +531,7 @@ TEST_F(CastAudioOutputStreamTest, Volume) {
 TEST_F(CastAudioOutputStreamTest, StartStopStart) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  ASSERT_TRUE(stream->Open());
+  ASSERT_TRUE(OpenStream(stream));
 
   ::media::MockAudioSourceCallback source_callback;
   EXPECT_CALL(source_callback, OnMoreData(_, _, _, _))
@@ -510,14 +553,14 @@ TEST_F(CastAudioOutputStreamTest, StartStopStart) {
 TEST_F(CastAudioOutputStreamTest, CloseWithoutStart) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  ASSERT_TRUE(stream->Open());
+  ASSERT_TRUE(OpenStream(stream));
   stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, AudioDelay) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  ASSERT_TRUE(stream->Open());
+  ASSERT_TRUE(OpenStream(stream));
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);

chromecast/media/cma/BUILD.gn

@@ -29,10 +29,12 @@ cast_source_set("test_support") {
     "test/mock_frame_consumer.h",
     "test/mock_frame_provider.cc",
     "test/mock_frame_provider.h",
+    "test/mock_multiroom_manager.h",
   ]
 
   deps = [
     "//base",
+    "//chromecast/common/mojom",
     "//chromecast/media/cma/backend",
     "//chromecast/media/cma/backend:null_video",
     "//chromecast/media/cma/base",

chromecast/media/cma/test/DEPS

 include_rules = [
+  "+chromecast/common/mojom",
   "+media/filters",
   "+media/video",
 ]

chromecast/media/cma/test/mock_multiroom_manager.h

+// Copyright 2018 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_CMA_TEST_MOCK_MULTIROOM_MANAGER_H_
+#define CHROMECAST_MEDIA_CMA_TEST_MOCK_MULTIROOM_MANAGER_H_
+
+#include <string>
+#include <utility>
+
+#include "base/bind.h"
+#include "chromecast/common/mojom/multiroom.mojom.h"
+#include "mojo/public/cpp/bindings/binding.h"
+
+namespace chromecast {
+namespace media {
+class MockMultiroomManager : public mojom::MultiroomManager {
+ public:
+  MockMultiroomManager();
+  ~MockMultiroomManager() override;
+
+  void Bind(mojo::ScopedMessagePipeHandle handle) {
+    binding_.Close();
+    binding_.Bind(mojom::MultiroomManagerRequest(std::move(handle)));
+  }
+
+  void GetMultiroomInfo(const std::string& session_id,
+                        GetMultiroomInfoCallback callback) override;
+
+ private:
+  mojo::Binding<mojom::MultiroomManager> binding_;
+};
+
+inline MockMultiroomManager::MockMultiroomManager() : binding_(this) {}
+
+inline MockMultiroomManager::~MockMultiroomManager() = default;
+
+inline void MockMultiroomManager::GetMultiroomInfo(
+    const std::string& session_id,
+    GetMultiroomInfoCallback callback) {
+  std::move(callback).Run(chromecast::mojom::MultiroomInfo::New());
+}
+
+}  // namespace media
+}  // namespace chromecast
+
+#endif  // CHROMECAST_MEDIA_CMA_TEST_MOCK_MULTIROOM_MANAGER_H_

chromecast/media/test/run_all_unittests.cc

@@ -7,6 +7,7 @@
 #include "base/test/test_suite.h"
 #include "build/build_config.h"
 #include "media/base/media.h"
+#include "mojo/core/embedder/embedder.h"
 
 class CastMediaTestSuite : public base::TestSuite {
  public:
@@ -29,6 +30,7 @@ void CastMediaTestSuite::Initialize() {
 
 int main(int argc, char** argv) {
   CastMediaTestSuite test_suite(argc, argv);
+  mojo::core::Init();
 
   return base::LaunchUnitTests(
       argc, argv,