Remove MockMediaInternals and incestuous usage.

content/browser/renderer_host/media/audio_renderer_host_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 "base/bind.h"
-#include "base/environment.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/sync_socket.h"
-#include "content/browser/browser_thread_impl.h"
+#include "content/browser/media/media_internals.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/audio_mirroring_manager.h"
 #include "content/browser/renderer_host/media/audio_renderer_host.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
-#include "content/browser/renderer_host/media/mock_media_observer.h"
 #include "content/common/media/audio_messages.h"
-#include "content/common/media/media_stream_options.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "ipc/ipc_message_utils.h"
 #include "media/audio/audio_manager.h"
-#include "media/audio/audio_manager_base.h"
-#include "media/audio/fake_audio_output_stream.h"
-#include "net/url_request/url_request_context.h"
+#include "media/base/bind_to_loop.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::DoAll;
 using ::testing::NotNull;
 
+namespace {
+const int kRenderProcessId = 1;
+const int kRenderViewId = 4;
+const int kStreamId = 50;
+}  // namespace
+
 namespace content {
 
-static const int kRenderProcessId = 1;
-static const int kRenderViewId = 4;
-static const int kStreamId = 50;
-
 class MockAudioMirroringManager : public AudioMirroringManager {
  public:
   MockAudioMirroringManager() {}
   virtual ~MockAudioMirroringManager() {}
 
   MOCK_METHOD3(AddDiverter,
-               void(int render_process_id, int render_view_id,
+               void(int render_process_id,
+                    int render_view_id,
                     Diverter* diverter));
   MOCK_METHOD3(RemoveDiverter,
-               void(int render_process_id, int render_view_id,
+               void(int render_process_id,
+                    int render_view_id,
                     Diverter* diverter));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioMirroringManager);
 };
 
 class MockAudioRendererHost : public AudioRendererHost {
  public:
-  explicit MockAudioRendererHost(
-      media::AudioManager* audio_manager,
-      AudioMirroringManager* mirroring_manager,
-      MediaInternals* media_internals,
-      MediaStreamManager* media_stream_manager)
+  explicit MockAudioRendererHost(media::AudioManager* audio_manager,

[tommi (sloooow) - chröme, 2013/11/22 11:55:31]

no need for explicit

[DaleCurtis, 2013/11/22 20:33:33]

Done.

+                                 AudioMirroringManager* mirroring_manager,
+                                 MediaInternals* media_internals,
+                                 MediaStreamManager* media_stream_manager)
       : AudioRendererHost(kRenderProcessId,
                           audio_manager,
                           mirroring_manager,
                           media_internals,
                           media_stream_manager),
-        shared_memory_length_(0) {
-  }
+        shared_memory_length_(0) {}
 
   // A list of mock methods.
-  MOCK_METHOD2(OnStreamCreated,
-               void(int stream_id, int length));
+  MOCK_METHOD2(OnStreamCreated, void(int stream_id, int length));
   MOCK_METHOD1(OnStreamPlaying, void(int stream_id));
   MOCK_METHOD1(OnStreamPaused, void(int stream_id));
   MOCK_METHOD1(OnStreamError, void(int stream_id));
 
  private:
   virtual ~MockAudioRendererHost() {
     // Make sure all audio streams have been deleted.
     EXPECT_TRUE(audio_entries_.empty());
   }
 
@@ skipping 12 matching lines @@
       IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamStateChanged,
                           OnStreamStateChanged)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     return true;
   }
 
-  void OnStreamCreated(const IPC::Message& msg, int stream_id,
+  void OnStreamCreated(const IPC::Message& msg,
+                       int stream_id,
                        base::SharedMemoryHandle handle,
 #if defined(OS_WIN)
                        base::SyncSocket::Handle socket_handle,
 #else
                        base::FileDescriptor socket_descriptor,
 #endif
                        uint32 length) {
     // Maps the shared memory.
     shared_memory_.reset(new base::SharedMemory(handle, false));
     CHECK(shared_memory_->Map(length));
     CHECK(shared_memory_->memory());
     shared_memory_length_ = length;
 
     // Create the SyncSocket using the handle.
     base::SyncSocket::Handle sync_socket_handle;
 #if defined(OS_WIN)
     sync_socket_handle = socket_handle;
 #else
     sync_socket_handle = socket_descriptor.fd;
 #endif
     sync_socket_.reset(new base::SyncSocket(sync_socket_handle));
 
     // And then delegate the call to the mock method.
     OnStreamCreated(stream_id, length);
   }
 
-  void OnStreamStateChanged(const IPC::Message& msg, int stream_id,
+  void OnStreamStateChanged(const IPC::Message& msg,
+                            int stream_id,
                             media::AudioOutputIPCDelegate::State state) {
     switch (state) {
       case media::AudioOutputIPCDelegate::kPlaying:
         OnStreamPlaying(stream_id);
         break;
       case media::AudioOutputIPCDelegate::kPaused:
         OnStreamPaused(stream_id);
         break;
       case media::AudioOutputIPCDelegate::kError:
         OnStreamError(stream_id);
         break;
       default:
         FAIL() << "Unknown stream state";
         break;
     }
   }
 
   scoped_ptr<base::SharedMemory> shared_memory_;
   scoped_ptr<base::SyncSocket> sync_socket_;
   uint32 shared_memory_length_;
 
   DISALLOW_COPY_AND_ASSIGN(MockAudioRendererHost);
 };
 
-ACTION_P(QuitMessageLoop, message_loop) {
-  message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
-}
-
 class AudioRendererHostTest : public testing::Test {
  public:
-  AudioRendererHostTest() : is_stream_active_(false) {}
-
- protected:
-  virtual void SetUp() {
-    // Create a message loop so AudioRendererHost can use it.
-    message_loop_.reset(new base::MessageLoop(base::MessageLoop::TYPE_IO));
-
-    // Claim to be on both the UI and IO threads to pass all the DCHECKS.
-    io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
-                                           message_loop_.get()));
-    ui_thread_.reset(new BrowserThreadImpl(BrowserThread::UI,
-                                           message_loop_.get()));
+  AudioRendererHostTest() {
     audio_manager_.reset(media::AudioManager::Create());
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
     media_stream_manager_->UseFakeDevice();
-    observer_.reset(new MockMediaInternals());
-    host_ = new MockAudioRendererHost(
-        audio_manager_.get(), &mirroring_manager_, observer_.get(),
-        media_stream_manager_.get());
+    host_ = new MockAudioRendererHost(audio_manager_.get(),
+                                      &mirroring_manager_,
+                                      MediaInternals::GetInstance(),
+                                      media_stream_manager_.get());
 
     // Simulate IPC channel connected.
     host_->set_peer_pid_for_testing(base::GetCurrentProcId());
   }
 
-  virtual void TearDown() {
+  virtual ~AudioRendererHostTest() {
     // Simulate closing the IPC channel.
     host_->OnChannelClosing();
 
     // Release the reference to the mock object.  The object will be destructed
     // on message_loop_.
     host_ = NULL;
-
-    // We need to continue running message_loop_ to complete all destructions.
-    SyncWithAudioThread();
-    audio_manager_.reset();
-
-    // Make sure the stream has been deleted before continuing.
-    while (is_stream_active_)
-      message_loop_->Run();
-
-    io_thread_.reset();
-    ui_thread_.reset();
-
-    // Delete the IO message loop.  This will cause the MediaStreamManager to be
-    // notified so it will stop its device thread and device managers.
-    message_loop_.reset();
   }
 
+ protected:
   void Create(bool unified_stream) {
-    EXPECT_CALL(*host_.get(), OnStreamCreated(kStreamId, _))
-        .WillOnce(DoAll(Assign(&is_stream_active_, true),
-                        QuitMessageLoop(message_loop_.get())));
+    EXPECT_CALL(*host_.get(), OnStreamCreated(kStreamId, _));
+
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderViewId, NotNull()))
         .RetiresOnSaturation();
 
     // Send a create stream message to the audio output stream and wait until
     // we receive the created message.
     int session_id;
     media::AudioParameters params;
     if (unified_stream) {
       // Use AudioInputDeviceManager::kFakeOpenSessionId as the session id to
       // pass the permission check.
       session_id = AudioInputDeviceManager::kFakeOpenSessionId;
       params = media::AudioParameters(
           media::AudioParameters::AUDIO_FAKE,
           media::CHANNEL_LAYOUT_STEREO,
           2,
           media::AudioParameters::kAudioCDSampleRate, 16,
           media::AudioParameters::kAudioCDSampleRate / 10);
     } else {
       session_id = 0;
       params = media::AudioParameters(
           media::AudioParameters::AUDIO_FAKE,
           media::CHANNEL_LAYOUT_STEREO,
           media::AudioParameters::kAudioCDSampleRate, 16,
           media::AudioParameters::kAudioCDSampleRate / 10);
     }
     host_->OnCreateStream(kStreamId, kRenderViewId, session_id, params);
-    message_loop_->Run();
 
     // At some point in the future, a corresponding RemoveDiverter() call must
     // be made.
     EXPECT_CALL(mirroring_manager_,
                 RemoveDiverter(kRenderProcessId, kRenderViewId, NotNull()))
         .RetiresOnSaturation();
-
-    // All created streams should ultimately be closed.
-    EXPECT_CALL(*observer_,
-                OnSetAudioStreamStatus(_, kStreamId, "closed"));
-
-    // Expect the audio stream will be deleted at some later point.
-    EXPECT_CALL(*observer_, OnDeleteAudioStream(_, kStreamId))
-        .WillOnce(DoAll(Assign(&is_stream_active_, false),
-                        QuitMessageLoop(message_loop_.get())));
+    SyncWithAudioThread();
   }
 
   void Close() {
     // Send a message to AudioRendererHost to tell it we want to close the
     // stream.
     host_->OnCloseStream(kStreamId);
-    if (is_stream_active_)
-      message_loop_->Run();
-    else
-      message_loop_->RunUntilIdle();
+    SyncWithAudioThread();
   }
 
   void Play() {
-    EXPECT_CALL(*observer_,
-                OnSetAudioStreamPlaying(_, kStreamId, true));
-    EXPECT_CALL(*host_.get(), OnStreamPlaying(kStreamId))
-        .WillOnce(QuitMessageLoop(message_loop_.get()));
-
+    EXPECT_CALL(*host_.get(), OnStreamPlaying(kStreamId));
     host_->OnPlayStream(kStreamId);
-    message_loop_->Run();
+    SyncWithAudioThread();
   }
 
   void Pause() {
-    EXPECT_CALL(*observer_,
-                OnSetAudioStreamPlaying(_, kStreamId, false));
-    EXPECT_CALL(*host_.get(), OnStreamPaused(kStreamId))
-        .WillOnce(QuitMessageLoop(message_loop_.get()));
-
+    EXPECT_CALL(*host_.get(), OnStreamPaused(kStreamId));
     host_->OnPauseStream(kStreamId);
-    message_loop_->Run();
+    SyncWithAudioThread();
   }
 
   void SetVolume(double volume) {
-    EXPECT_CALL(*observer_,
-                OnSetAudioStreamVolume(_, kStreamId, volume));
-
     host_->OnSetVolume(kStreamId, volume);
-    message_loop_->RunUntilIdle();
+    SyncWithAudioThread();
   }
 
   void SimulateError() {
-    EXPECT_CALL(*observer_,
-                OnSetAudioStreamStatus(_, kStreamId, "error"));
     EXPECT_EQ(1u, host_->audio_entries_.size())
         << "Calls Create() before calling this method";
 
     // Expect an error signal sent through IPC.
     EXPECT_CALL(*host_.get(), OnStreamError(kStreamId));
 
     // Simulate an error sent from the audio device.
     host_->ReportErrorAndClose(kStreamId);
     SyncWithAudioThread();
 
     // Expect the audio stream record is removed.
     EXPECT_EQ(0u, host_->audio_entries_.size());
   }
 
   // Called on the audio thread.
-  static void PostQuitMessageLoop(base::MessageLoop* message_loop) {
-    message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
-  }
-
-  // Called on the main thread.
-  static void PostQuitOnAudioThread(media::AudioManager* audio_manager,
-                                    base::MessageLoop* message_loop) {
-    audio_manager->GetMessageLoop()->PostTask(FROM_HERE,
-        base::Bind(&PostQuitMessageLoop, message_loop));
+  static void PostQuitMessageLoop(const base::Closure& quit_closure) {
+    quit_closure.Run();
   }
 
   // SyncWithAudioThread() waits until all pending tasks on the audio thread
   // are executed while also processing pending task in message_loop_ on the
   // current thread. It is used to synchronize with the audio thread when we are
   // closing an audio stream.
   void SyncWithAudioThread() {
-    // Don't use scoped_refptr to addref the media::AudioManager when posting
-    // to the thread that itself owns.
-    message_loop_->PostTask(
-        FROM_HERE, base::Bind(&PostQuitOnAudioThread,
-            base::Unretained(audio_manager_.get()),
-            message_loop_.get()));
-    message_loop_->Run();
+    base::RunLoop().RunUntilIdle();
+
+    base::RunLoop run_loop;
+    audio_manager_->GetMessageLoop()->PostTask(
+        FROM_HERE, media::BindToCurrentLoop(base::Bind(
+            &AudioRendererHostTest::PostQuitMessageLoop,

[acolwell GONE FROM CHROMIUM, 2013/11/22 19:12:48]

Why do you need PostQuitMessageLoop? You should be able to
media::BindToCurrentLoop(run_loop.QuitClosure()).

[DaleCurtis, 2013/11/22 20:33:33]

Derp. It was left over from a previous incarnation.

+            run_loop.QuitClosure())));
+    run_loop.Run();
   }
 
  private:
-  scoped_ptr<MockMediaInternals> observer_;
+  // MediaStreamManager uses a DestructionObserver, so it must outlive the
+  // TestBrowserThreadBundle.
+  scoped_ptr<MediaStreamManager> media_stream_manager_;
+  TestBrowserThreadBundle thread_bundle_;
+  scoped_ptr<media::AudioManager> audio_manager_;
   MockAudioMirroringManager mirroring_manager_;
   scoped_refptr<MockAudioRendererHost> host_;
-  scoped_ptr<base::MessageLoop> message_loop_;
-  scoped_ptr<BrowserThreadImpl> io_thread_;
-  scoped_ptr<BrowserThreadImpl> ui_thread_;
-  scoped_ptr<media::AudioManager> audio_manager_;
-  scoped_ptr<MediaStreamManager> media_stream_manager_;
-
-  bool is_stream_active_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererHostTest);
 };
 
 TEST_F(AudioRendererHostTest, CreateAndClose) {
   Create(false);
   Close();
 }
 
 // Simulate the case where a stream is not properly closed.
@@ skipping 52 matching lines @@
 }
 
 TEST_F(AudioRendererHostTest, CreateUnifiedStreamAndClose) {
   Create(true);
   Close();
 }
 
 // TODO(hclam): Add tests for data conversation in low latency mode.
 
 }  // namespace content