Factor out AudioOutputDelegate from AudioRendererHost.

content/browser/renderer_host/media/audio_output_delegate_unittest.cc

+// 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 <utility>
+
+#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/browser/browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "media/audio/fake_audio_log_factory.h"
+#include "media/audio/fake_audio_manager.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;
+
+// Not yet tested:
+// - Interactions with AudioStreamMonitor (goes through WebContentsImpl,
+//   so it's a bit tricky).
+// - Logging (small risk of bugs, not worth the effort).
+// - That the returned socket/memory is correctly set up.
+
+namespace content {
+
+namespace {
+
+const int kRenderProcessId = 1;
+const int kRenderFrameId = 5;
+const int kStreamId = 50;
+const char kDefaultDeviceId[] = "";
+
+struct MockAudioMirroringManager : public AudioMirroringManager {
+  MockAudioMirroringManager() = default;
+  ~MockAudioMirroringManager() override = default;
+
+  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);
+
+    thread_bundle_ = base::MakeUnique<TestBrowserThreadBundle>(
+        TestBrowserThreadBundle::Options::REAL_IO_THREAD);

[o1ka, 2016/11/22 21:48:16]

Add a comment on why this threading setup is chosen for tests (IO/UI/Audio
thread)

[Max Morin, 2016/11/25 15:32:35]

Done.

+    audio_thread_ = base::MakeUnique<base::Thread>("AudioThread");
+
+// Audio manager creation stolen from content/browser/browser_main_loop.cc.
+#if defined(OS_WIN)
+    audio_thread_->init_com_with_mta(true);
+#endif  // defined(OS_WIN)
+    CHECK(audio_thread_->Start());
+
+#if defined(OS_MACOSX)
+    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner =
+        base::ThreadTaskRunnerHandle::Get();
+#else
+    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner =
+        audio_thread_->task_runner();
+#endif  // defined(OS_MACOSX)
+
+    audio_manager_.reset(new media::FakeAudioManager(
+        audio_task_runner, audio_thread_->task_runner(), &log_factory_));
+    media_stream_manager_ =
+        base::MakeUnique<MediaStreamManager>(audio_manager_.get());
+  }
+
+  ~AudioOutputDelegateTest() override = default;
+
+  AudioOutputDelegate::UniquePtr CreateDelegateOnIOAndSync() {
+    AudioOutputDelegate::UniquePtr delegate;
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&AudioOutputDelegateTest::CreateDelegateOnIO,
+                   base::Unretained(this), base::Unretained(&delegate)));
+    SyncWithAllThreads();
+    return delegate;
+  }
+
+  void CreateDelegateOnIO(AudioOutputDelegate::UniquePtr* delegate) {
+    *delegate = 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:
+  void SyncWithAllThreads() {
+    // New tasks might be posted while we are syncing, but in every iteration at
+    // least one task will be run. 20 iterations should be enough for our code.
+    for (int i = 0; i < 20; ++i) {
+      base::RunLoop().RunUntilIdle();
+      SyncWith(BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
+      SyncWith(audio_thread_->task_runner());
+    }
+  }
+
+  // MediaStreamManager uses a DestructionObserver, so it must outlive the
+  // TestBrowserThreadBundle.
+  std::unique_ptr<MediaStreamManager> media_stream_manager_;
+  std::unique_ptr<TestBrowserThreadBundle> thread_bundle_;
+  std::unique_ptr<base::Thread> audio_thread_;
+  media::ScopedAudioManagerPtr audio_manager_;
+  NiceMock<MockAudioMirroringManager> mirroring_manager_;
+  NiceMock<MockEventHandler> event_handler_;
+  NiceMock<MockObserver> media_observer_;
+  media::FakeAudioLogFactory log_factory_;
+
+ private:
+  void SyncWith(scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+    CHECK(task_runner);
+    CHECK(!task_runner->BelongsToCurrentThread());
+    base::WaitableEvent e = {base::WaitableEvent::ResetPolicy::MANUAL,
+                             base::WaitableEvent::InitialState::NOT_SIGNALED};
+    task_runner->PostTask(FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
+                                                base::Unretained(&e)));
+    e.Wait();
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(AudioOutputDelegateTest);
+};
+
+TEST_F(AudioOutputDelegateTest, CreateAndDelete) {
+  EXPECT_CALL(media_observer_,
+              OnCreatingAudioStream(kRenderProcessId, kRenderFrameId))
+      .Times(1);
+  EXPECT_CALL(event_handler_, OnStreamCreated(kStreamId, NotNull(), NotNull()));
+  EXPECT_CALL(mirroring_manager_,
+              AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()))
+      .Times(1);
+
+  AudioOutputDelegate::UniquePtr delegate = CreateDelegateOnIOAndSync();
+
+  SyncWithAllThreads();
+  EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())).Times(1);
+
+  // Delete delegate on IO thread:
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind([](AudioOutputDelegate::UniquePtr delegate) {},
+                 base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+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 = CreateDelegateOnIOAndSync();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPlayStream,
+                                     base::Unretained(delegate.get())));
+  SyncWithAllThreads();
+  BrowserThread::PostTask(

[o1ka, 2016/11/22 21:48:16]

I still think it does not make sense to post each step to IO thread separately
and then wait for its completion, and it is not what happens in real life.

[Max Morin, 2016/11/25 15:32:35]

I fixed this now.

+      BrowserThread::IO, FROM_HERE,
+      base::Bind([](AudioOutputDelegate::UniquePtr delegate) {},
+                 base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+TEST_F(AudioOutputDelegateTest, PlayAndDestroy_DoesNotCallHandler) {
+  EXPECT_CALL(event_handler_, OnStreamStateChanged(_)).Times(0);
+
+  AudioOutputDelegate::UniquePtr delegate = CreateDelegateOnIOAndSync();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(
+                              [](AudioOutputDelegate::UniquePtr delegate) {
+                                delegate->OnPlayStream();
+                                delegate.reset();
+                              },
+                              base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+TEST_F(AudioOutputDelegateTest, Error_CallsHandler) {
+  EXPECT_CALL(event_handler_, OnStreamError(kStreamId)).Times(1);
+
+  AudioOutputDelegate::UniquePtr delegate = CreateDelegateOnIOAndSync();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&media::AudioOutputController::OnError,
+                                     delegate->controller(), nullptr));
+  SyncWithAllThreads();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind([](AudioOutputDelegate::UniquePtr delegate) {},
+                 base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+TEST_F(AudioOutputDelegateTest, ErrorAndDestroy_DoesNotCallHandler) {
+  EXPECT_CALL(event_handler_, OnStreamError(kStreamId)).Times(0);
+
+  AudioOutputDelegate::UniquePtr delegate = CreateDelegateOnIOAndSync();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(
+                              [](AudioOutputDelegate::UniquePtr delegate) {
+                                delegate->controller()->OnError(nullptr);
+                                delegate.reset();
+                              },
+                              base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+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 = CreateDelegateOnIOAndSync();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPlayStream,
+                                     base::Unretained(delegate.get())));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPauseStream,
+                                     base::Unretained(delegate.get())));
+  SyncWithAllThreads();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind([](AudioOutputDelegate::UniquePtr delegate) {},
+                 base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+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 = CreateDelegateOnIOAndSync();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPlayStream,
+                                     base::Unretained(delegate.get())));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPauseStream,
+                                     base::Unretained(delegate.get())));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPlayStream,
+                                     base::Unretained(delegate.get())));
+  SyncWithAllThreads();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind([](AudioOutputDelegate::UniquePtr delegate) {},
+                 base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+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 = CreateDelegateOnIOAndSync();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPlayStream,
+                                     base::Unretained(delegate.get())));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPlayStream,
+                                     base::Unretained(delegate.get())));
+  SyncWithAllThreads();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind([](AudioOutputDelegate::UniquePtr delegate) {},
+                 base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+TEST_F(AudioOutputDelegateTest,
+       PauseAfterCreation_DoesNotCallOnStreamStateChanged) {
+  EXPECT_CALL(event_handler_, OnStreamStateChanged(_)).Times(0);
+
+  AudioOutputDelegate::UniquePtr delegate = CreateDelegateOnIOAndSync();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&AudioOutputDelegate::OnPauseStream,
+                                     base::Unretained(delegate.get())));
+  SyncWithAllThreads();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind([](AudioOutputDelegate::UniquePtr delegate) {},
+                 base::Passed(std::move(delegate))));
+  SyncWithAllThreads();
+}
+
+TEST_F(AudioOutputDelegateTest, CreateAndDestroy_DoesNotCallHandler) {
+  EXPECT_CALL(event_handler_, OnStreamCreated(_, _, _)).Times(0);
+
+  AudioOutputDelegate::UniquePtr delegate;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(
+                              [](AudioOutputDelegateTest* test) {
+                                AudioOutputDelegate::UniquePtr delegate;
+                                test->CreateDelegateOnIO(&delegate);
+                              },
+                              base::Unretained(this)));
+  SyncWithAllThreads();
+}
+
+}  // namespace content