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

content/browser/media/audio_output_stream_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/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 kStreamId1 = 9;
+// const int kStreamId2 = 20;
+
+// const int kStreamIds[] = {800, 2, 30, 22};
+// const unsigned int kStreamIdsSize = 4;
+const int kRenderProcessId = 1;
+
+std::string ReturnMockSalt() {
+  return std::string();
+}
+
+ResourceContext::SaltCallback GetMockSaltCallback() {
+  return base::Bind(&ReturnMockSalt);
+}
+}
+
+class MockAudioOutputImpl : public AudioOutputImpl {
+ public:
+  MockAudioOutputImpl(scoped_refptr<AudioRendererHost> audio_renderer_host,
+                      int render_frame_id,
+                      media::mojom::AudioOutputRequest request)
+      : AudioOutputImpl(audio_renderer_host,
+                        render_frame_id,
+                        std::move(request)) {}
+
+  MOCK_METHOD1(RemoveStream, bool(int stream_id));
+  DISALLOW_COPY_AND_ASSIGN(MockAudioOutputImpl);
+};
+
+class MockAudioOutputStreamAudioRendererHost : public AudioRendererHost {
+ public:
+  MockAudioOutputStreamAudioRendererHost(
+      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));
+
+ protected:
+  FRIEND_TEST_ALL_PREFIXES(AudioOutputStreamImplTest, Close);
+  friend class AudioOutputStreamImplTest;
+  virtual ~MockAudioOutputStreamAudioRendererHost() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockAudioOutputStreamAudioRendererHost);
+};
+
+class AudioOutputStreamImplTest : public ::testing::Test {
+ public:
+  AudioOutputStreamImplTest() {
+    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 MockAudioOutputStreamAudioRendererHost(
+        kRenderProcessId, audio_manager_.get(), &mirroring_manager_,
+        MediaInternals::GetInstance(), media_stream_manager_.get(),
+        GetMockSaltCallback()));
+
+    audio_output_impl_.reset(
+        new MockAudioOutputImpl(audio_renderer_host_, kRenderFrameId1,
+                                media::mojom::AudioOutputRequest()));
+    audio_renderer_host_->set_audio_output_impl(kRenderFrameId1,
+                                                audio_output_impl_.get());
+  }
+
+  ~AudioOutputStreamImplTest() override { audio_renderer_host_ = NULL; }
+
+ protected:
+  // MockAudioOutputStreamAudioRendererHost* audio_renderer_host_;
+  std::unique_ptr<MockAudioOutputImpl> audio_output_impl_;
+
+  scoped_refptr<MockAudioOutputStreamAudioRendererHost> audio_renderer_host_;
+
+ private:
+  media::ScopedAudioManagerPtr audio_manager_;
+  std::unique_ptr<MediaStreamManager> media_stream_manager_;
+  TestBrowserThreadBundle thread_bundle_;
+  AudioMirroringManager mirroring_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioOutputStreamImplTest);
+};
+
+TEST_F(AudioOutputStreamImplTest, Close) {
+  media::mojom::AudioOutputStreamPtr stream1 =
+      media::mojom::AudioOutputStreamPtr();
+
+  std::unique_ptr<AudioOutputStreamImpl> stream_ptr1(
+      new AudioOutputStreamImpl(mojo::GetProxy(&stream1), kStreamId1,
+                                kRenderFrameId1, audio_renderer_host_.get()));
+
+  EXPECT_CALL(*audio_renderer_host_.get(), CloseStream(kStreamId1));
+
+  EXPECT_CALL(*audio_output_impl_, RemoveStream(kStreamId1)).Times(1);
+  stream_ptr1->Close();
+}
+}  // namespace content