Switch stream creation and closing in Chrome audio rendering from IPC to Mojo

content/browser/media/audio_output_impl_unittest.cc

+// Copyright (c) 2016 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 <stdint.h>
+#include <string>
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "content/browser/media/audio_output_impl.h"
+#include "content/browser/media/audio_output_stream_impl.h"
+#include "content/browser/media/capture/audio_mirroring_manager.h"
+#include "content/browser/media/media_internals.h"
+#include "content/browser/renderer_host/media/media_stream_manager.h"
+#include "content/public/test/mock_render_process_host.h"
+#include "content/public/test/test_browser_context.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "media/audio/audio_manager.h"
+#include "media/base/media_switches.h"
+#include "media/mojo/interfaces/audio_output.mojom.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::Return;
+/*
+namespace content {
+
+namespace {
+
+const int kRenderFrameId1 = 5;
+const int kRenderFrameId2 = 3;
+const int kRenderProcessId = 1;
+const int kStreamId1 = 9;
+const int kStreamId2 = 20;
+const int kStreamIds[] = {800, 2, 30, 22};
+const unsigned int kStreamIdsSize = 4;
+
+std::string ReturnMockSalt() {
+  return std::string();
+}
+
+ResourceContext::SaltCallback GetMockSaltCallback() {
+  return base::Bind(&ReturnMockSalt);
+}
+}
+
+class MockAudioOutputStreamImpl : public AudioOutputStreamImpl {
+ public:
+  explicit MockAudioOutputStreamImpl(
+      media::mojom::AudioOutputStreamRequest request,
+      int stream_id,
+      int renderer_frame_id,
+      AudioRendererHost* audio_renderer_host)
+      : AudioOutputStreamImpl(std::move(request),
+                              stream_id,
+                              renderer_frame_id,
+                              audio_renderer_host) {}
+  MOCK_METHOD0(Close, void());
+};
+
+class MockAudioRendererHost : public AudioRendererHost {
+ public:
+  MockAudioRendererHost(int render_process_id,
+                        media::AudioManager* audio_manager,
+                        AudioMirroringManager* mirroring_manager,
+                        MediaInternals* media_internals,
+                        MediaStreamManager* media_stream_manager,
+                        const ResourceContext::SaltCallback& salt_callback)
+      : AudioRendererHost(render_process_id,
+                          audio_manager,
+                          mirroring_manager,
+                          media_internals,
+                          media_stream_manager,
+                          salt_callback) {}
+
+  MOCK_METHOD1(CloseStream, void(int stream_id));
+  MOCK_METHOD4(
+      CreateStream,
+      void(int stream_id,
+           int render_frame_id,
+           const media::AudioParameters& params,
+           const media::mojom::AudioOutput::CreateStreamCallback& callback));
+
+  MOCK_METHOD2(
+      DoCompleteCreation,
+      void(int stream_id,
+           const media::mojom::AudioOutput::CreateStreamCallback& callback));
+  MOCK_METHOD2(set_audio_output_impl,
+               void(int render_frame_id, AudioOutputImpl* audio_output_impl));
+
+ protected:
+  FRIEND_TEST_ALL_PREFIXES(AudioOutputImplTest, CreateServiceOnIOThread);
+  FRIEND_TEST_ALL_PREFIXES(AudioOutputImplTest, CreateStream);
+  friend class AudioOutputImplTest;
+  virtual ~MockAudioRendererHost() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockAudioRendererHost);
+};
+
+class TestRenderProcessHost : public MockRenderProcessHost {
+ public:
+  TestRenderProcessHost(BrowserContext* context)
+      : MockRenderProcessHost(context) {}
+  scoped_refptr<AudioRendererHost> audio_renderer_host() const override {
+    return audio_renderer_host_;
+  }
+  scoped_refptr<AudioRendererHost> audio_renderer_host_;
+};
+
+class AudioOutputImplTest : public ::testing::Test {
+ public:
+  AudioOutputImplTest() {
+    browser_context_.reset(new TestBrowserContext);
+    render_process_host_.reset(
+        new TestRenderProcessHost(browser_context_.get()));
+
+    audio_manager_ = media::AudioManager::CreateForTesting(
+        base::ThreadTaskRunnerHandle::Get());
+
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kUseFakeDeviceForMediaStream);
+    media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
+
+    // Enable caching to make enumerations run in a single thread
+    media_stream_manager_->audio_output_device_enumerator()->SetCachePolicy(
+        AudioOutputDeviceEnumerator::CACHE_POLICY_MANUAL_INVALIDATION);
+
+    audio_renderer_host_ = new MockAudioRendererHost(
+        kRenderProcessId, audio_manager_.get(), &mirroring_manager_,
+        MediaInternals::GetInstance(), media_stream_manager_.get(),
+        GetMockSaltCallback());
+
+    render_process_host_->audio_renderer_host_ = audio_renderer_host_;
+  }
+  void CreateCallback(int stream_id,
+                      media::mojom::AudioOutputStreamPtr stream,
+                      mojo::ScopedSharedBufferHandle shared_buffer,
+                      mojo::ScopedHandle socket_descriptor) {}
+
+  ~AudioOutputImplTest() override {}
+
+ private:
+  media::ScopedAudioManagerPtr audio_manager_;
+  std::unique_ptr<BrowserContext> browser_context_;
+  std::unique_ptr<MediaStreamManager> media_stream_manager_;
+  AudioMirroringManager mirroring_manager_;
+  TestBrowserThreadBundle thread_bundle_;
+
+ protected:
+  std::unique_ptr<TestRenderProcessHost> render_process_host_;
+  MockAudioRendererHost* audio_renderer_host_;
+  std::unique_ptr<base::MessageLoop> message_loop_;
+  DISALLOW_COPY_AND_ASSIGN(AudioOutputImplTest);
+};
+
+TEST_F(AudioOutputImplTest, CreateStream) {
+  auto callback =
+      base::Bind(&AudioOutputImplTest::CreateCallback, base::Unretained(this));
+
+  media::AudioParameters params(
+      media::AudioParameters::AUDIO_FAKE, media::CHANNEL_LAYOUT_STEREO,
+      media::AudioParameters::kAudioCDSampleRate, 16,
+      media::AudioParameters::kAudioCDSampleRate / 10);
+
+  EXPECT_CALL(*audio_renderer_host_,
+              CreateStream(kStreamId1, kRenderFrameId1, _, _))
+      .Times(1);
+
+  AudioOutputImpl audio_output_impl1(render_process_host_.get(),
+                                     kRenderFrameId1,
+                                     media::mojom::AudioOutputRequest());
+  audio_output_impl1.CreateStream(kStreamId1, params, callback);
+
+  EXPECT_CALL(*audio_renderer_host_,
+              CreateStream(kStreamId2, kRenderFrameId2, _, _))
+      .Times(1);
+
+  AudioOutputImpl audio_output_impl2(render_process_host_.get(),
+                                     kRenderFrameId2,
+                                     media::mojom::AudioOutputRequest());
+  audio_output_impl2.CreateStream(kStreamId2, params, callback);
+}
+
+TEST_F(AudioOutputImplTest, StreamFactory) {
+  AudioOutputImpl audio_output_impl(render_process_host_.get(), kRenderFrameId1,
+                                    media::mojom::AudioOutputRequest());
+  EXPECT_EQ(0u, audio_output_impl.stream_impls_.size());
+  unsigned int i = 0;
+  for (i = 0; i < kStreamIdsSize; i++) {
+    auto stream = audio_output_impl.StreamFactory(
+        kStreamIds[i], kRenderFrameId1, audio_renderer_host_);
+    EXPECT_TRUE(stream.is_bound());
+    EXPECT_NE(audio_output_impl.stream_impls_.end(),
+              audio_output_impl.stream_impls_.find(kStreamIds[i]));
+    EXPECT_EQ(kStreamIds[i],
+              audio_output_impl.stream_impls_[kStreamIds[i]]->get_stream_id());
+
+    EXPECT_EQ(i + 1, audio_output_impl.stream_impls_.size());
+  }
+}
+
+TEST_F(AudioOutputImplTest, RemoveStream) {
+  AudioOutputImpl audio_output_impl(render_process_host_.get(), kRenderFrameId1,
+                                    media::mojom::AudioOutputRequest());
+
+  EXPECT_EQ(0u, audio_output_impl.stream_impls_.size());
+  // Remove a stream from an empty audio_output_impl should not be possible.
+  EXPECT_FALSE(audio_output_impl.RemoveStream(kStreamId1));
+  EXPECT_EQ(0u, audio_output_impl.stream_impls_.size());
+  unsigned int i = 0;
+  // Fill stream_impls_ with streams.
+  for (i = 0; i < kStreamIdsSize; i++) {
+    auto stream = audio_output_impl.StreamFactory(
+        kStreamIds[i], kRenderFrameId1, audio_renderer_host_);
+    EXPECT_NE(audio_output_impl.stream_impls_.end(),
+              audio_output_impl.stream_impls_.find(kStreamIds[i]));
+    EXPECT_EQ(kStreamIds[i],
+              audio_output_impl.stream_impls_[kStreamIds[i]]->get_stream_id());
+    EXPECT_EQ(i + 1, audio_output_impl.stream_impls_.size());
+  }
+  // Remove streams.
+  for (i = 0; i < kStreamIdsSize; i++) {
+    EXPECT_TRUE(audio_output_impl.RemoveStream(kStreamIds[i]));
+    EXPECT_EQ(audio_output_impl.stream_impls_.end(),
+              audio_output_impl.stream_impls_.find(kStreamIds[i]));
+    EXPECT_EQ(kStreamIdsSize - i - 1, audio_output_impl.stream_impls_.size());
+  }
+}
+
+}  // namespace content
+*/