Reland "Fetch and apply Multiroom info in CAOS"

Relanding go/chromium-cl/1145892 with the fix.

This reverts commit 3f6d2857.

Bug: b/111694183
Test: Numerous runs of cast_media_unittest
Change-Id: I46dd922bd99e8a957d90446cfcebd56f405fdc0f
Reviewed-on: https://chromium-review.googlesource.com/1153504Reviewed-by: Scott Violet <sky@chromium.org>
Commit-Queue: Aidan Wolter <awolter@chromium.org>
Cr-Commit-Position: refs/heads/master@{#578798}

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,56 @@ 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();
+    // 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;
+  }
+
+  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 +117,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,