Factor out AudioOutputDelegate from AudioRendererHost.

content/browser/renderer_host/media/audio_output_delegate_unittest.cc

Index: content/browser/renderer_host/media/audio_output_delegate_unittest.cc
diff --git a/content/browser/renderer_host/media/audio_output_delegate_unittest.cc b/content/browser/renderer_host/media/audio_output_delegate_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9c7c4f281c9c01cf820b0e51c3e9c03f3279fd4c
--- /dev/null
+++ b/content/browser/renderer_host/media/audio_output_delegate_unittest.cc
@@ -0,0 +1,272 @@
+// Copyright (c) 2012 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 "content/browser/renderer_host/media/audio_output_delegate.h"
+
+#include <stdint.h>
+
+#include <memory>
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/run_loop.h"
+#include "content/browser/media/capture/audio_mirroring_manager.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/audio/fake_audio_log_factory.h"
+#include "media/base/media_switches.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::InSequence;
+using ::testing::NiceMock;
+using ::testing::NotNull;
+
+namespace content {

[o1ka, 2016/11/03 13:39:12]

nit: empty line after each namespace {

[Max Morin, 2016/11/18 16:03:42]

Done.

+namespace {
+const int kRenderProcessId = 1;
+const int kRenderFrameId = 5;
+const int kStreamId = 50;
+const char kDefaultDeviceId[] = "";
+
+struct MockAudioMirroringManager : public AudioMirroringManager {
+  MockAudioMirroringManager() : AudioMirroringManager() {}
+  virtual ~MockAudioMirroringManager() {}
+
+  MOCK_METHOD3(AddDiverter,
+               void(int render_process_id,
+                    int render_frame_id,
+                    Diverter* diverter));
+  MOCK_METHOD1(RemoveDiverter, void(Diverter* diverter));
+};
+
+struct MockObserver : public content::MediaObserver {
+  void OnAudioCaptureDevicesChanged() override {}
+  void OnVideoCaptureDevicesChanged() override {}
+  void OnMediaRequestStateChanged(int render_process_id,
+                                  int render_frame_id,
+                                  int page_request_id,
+                                  const GURL& security_origin,
+                                  MediaStreamType stream_type,
+                                  MediaRequestState state) override {}
+  void OnSetCapturingLinkSecured(int render_process_id,
+                                 int render_frame_id,
+                                 int page_request_id,
+                                 MediaStreamType stream_type,
+                                 bool is_secure) override {}
+
+  MOCK_METHOD2(OnCreatingAudioStream,
+               void(int render_process_id, int render_frame_id));
+};
+
+struct MockEventHandler : public AudioOutputDelegate::EventHandler {
+  MOCK_METHOD1(OnStreamStateChanged, void(bool playing));
+  MOCK_METHOD3(OnStreamCreated,
+               void(int stream_id,
+                    base::SharedMemory* shared_memory,
+                    base::CancelableSyncSocket* socket));
+  MOCK_METHOD1(OnStreamError, void(int stream_id));
+};
+
+}  // namespace
+
+class AudioOutputDelegateTest : public testing::Test {
+ public:
+  AudioOutputDelegateTest() {
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kUseFakeDeviceForMediaStream);
+
+    audio_manager_ = media::AudioManager::CreateForTesting(
+        base::ThreadTaskRunnerHandle::Get());
+    media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
+  }
+
+  ~AudioOutputDelegateTest() override {}
+
+  AudioOutputDelegate::UniquePtr Create() {
+    return AudioOutputDelegate::Create(
+        &event_handler_, audio_manager_.get(),
+        log_factory_.CreateAudioLog(
+            media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+        &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
+        kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(),
+        kDefaultDeviceId);
+  }
+
+ protected:
+  // MediaStreamManager uses a DestructionObserver, so it must outlive the
+  // TestBrowserThreadBundle.
+  std::unique_ptr<MediaStreamManager> media_stream_manager_;
+  TestBrowserThreadBundle thread_bundle_;

[o1ka, 2016/11/03 13:39:12]

Do we want to have some real threads? (I think we do, because of our complex
deletion chain)

[Max Morin, 2016/11/18 16:03:42]

Done. I learned from the authorization CL that a separate UI thread is a bad
idea (since it'll mess up global state for other tests), but I added IO and
audio threads.

+  media::ScopedAudioManagerPtr audio_manager_;
+  NiceMock<MockAudioMirroringManager> mirroring_manager_;
+  NiceMock<MockEventHandler> event_handler_;
+  NiceMock<MockObserver> media_observer_;
+  media::FakeAudioLogFactory log_factory_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AudioOutputDelegateTest);
+};
+
+TEST_F(AudioOutputDelegateTest, Create_AlertsObserver) {
+  EXPECT_CALL(media_observer_,
+              OnCreatingAudioStream(kRenderProcessId, kRenderFrameId))
+      .Times(1);
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  // Due to complex destruction of AudioOutputDelegate, we first flush all
+  // operations, then destroy, then make sure the destruction is done by
+  // calling RunUntilIdle again.
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest, Create_CallsHandler) {
+  EXPECT_CALL(event_handler_, OnStreamCreated(kStreamId, NotNull(), NotNull()));
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest, CreateAndDestroy_DoesNotCallHandler) {
+  EXPECT_CALL(event_handler_, OnStreamCreated(_, _, _)).Times(0);
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest,
+       Create_RegistersAndUnregistersControllerWithMirroringManager) {
+  {
+    InSequence s;
+    EXPECT_CALL(mirroring_manager_,
+                AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()))
+        .Times(1);
+    EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())).Times(1);
+  }
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest, Play_CallsHandler) {
+  {
+    InSequence s;
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(true)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(false)).Times(1);
+  }
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate->OnPlayStream();
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest, PlayAndDestroy_DoesNotCallHandler) {
+  EXPECT_CALL(event_handler_, OnStreamStateChanged(_)).Times(0);
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate->OnPlayStream();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest, Error_CallsHandler) {
+  EXPECT_CALL(event_handler_, OnStreamError(kStreamId)).Times(1);
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate->controller()->OnError(nullptr);
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest, ErrorAndDestroy_DoesNotCallHandler) {
+  EXPECT_CALL(event_handler_, OnStreamError(kStreamId)).Times(0);
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate->controller()->OnError(nullptr);
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest, PlayPause_CallsHandlerCorrectNumberOfTimes) {
+  {
+    InSequence s;
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(true)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(false)).Times(1);
+  }
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate->OnPlayStream();
+  delegate->OnPauseStream();
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest,
+       PlayPausePlay_CallsHandlerCorrectNumberOfTimes) {
+  {
+    InSequence s;
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(true)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(false)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(true)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(false)).Times(1);
+  }
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate->OnPlayStream();
+  delegate->OnPauseStream();
+  delegate->OnPlayStream();
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest,
+       PlayPausePlayPause_CallsHandlerCorrectNumberOfTimes) {
+  {
+    InSequence s;
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(true)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(false)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(true)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(false)).Times(1);
+  }
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate->OnPlayStream();
+  delegate->OnPauseStream();
+  delegate->OnPlayStream();
+  delegate->OnPauseStream();
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(AudioOutputDelegateTest, PlayPlay_CallsHandlerCorrectNumberOfTimes) {
+  {
+    InSequence s;
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(true)).Times(1);
+    EXPECT_CALL(event_handler_, OnStreamStateChanged(false)).Times(1);
+  }
+
+  AudioOutputDelegate::UniquePtr delegate = Create();
+  delegate->OnPlayStream();
+  delegate->OnPlayStream();
+  base::RunLoop().RunUntilIdle();
+  delegate.reset();
+  base::RunLoop().RunUntilIdle();
+}
+
+}  // namespace content