Move the device enumerate/open/close work to device thread from IO thread

content/browser/renderer_host/media/media_stream_dispatcher_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 <string>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/mock_media_observer.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "ipc/ipc_message_macros.h"
-#include "media/audio/audio_manager.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::Return;
 
 using content::BrowserThread;
 using content::BrowserThreadImpl;
 
 const int kProcessId = 5;
 const int kRenderId = 6;
 const int kPageRequestId = 7;
 
 namespace media_stream {
 
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public content::TestContentBrowserClient {
  public:
   MockMediaStreamDispatcherHost(content::ResourceContext* resource_context,
-                                MessageLoop* message_loop,
-                                media::AudioManager* audio_manager)
-      : MediaStreamDispatcherHost(resource_context, kProcessId, audio_manager),
+                                MessageLoop* message_loop)
+      : MediaStreamDispatcherHost(resource_context, kProcessId),
         message_loop_(message_loop) {}
 
   // A list of mock methods.
   MOCK_METHOD4(OnStreamGenerated,
                void(int routing_id, int request_id, int audio_array_size,
                     int video_array_size));
   MOCK_METHOD2(OnStreamGenerationFailed, void(int routing_id, int request_id));
   MOCK_METHOD2(OnAudioDeviceFailed, void(int routing_id, int index));
   MOCK_METHOD2(OnVideoDeviceFailed, void(int routing_id, int index));
   MOCK_METHOD0(GetMediaObserver, content::MediaObserver*());
@@ skipping 99 matching lines @@
  protected:
   virtual void SetUp() {
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
     // ResourceContext must be created on UI thread.
     ui_thread_.reset(new BrowserThreadImpl(BrowserThread::UI,
                                            message_loop_.get()));
     // MediaStreamManager must be created and called on IO thread.
     io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
                                            message_loop_.get()));
 
-    audio_manager_.reset(media::AudioManager::Create());
-
     // Create our own media observer.
     media_observer_.reset(new MockMediaObserver());
 
     // Make sure we use fake devices to avoid long delays.
     MediaStreamManager::GetForResourceContext(
-        &resource_context_, audio_manager_.get())->UseFakeDevice();
+        &resource_context_)->UseFakeDevice();
 
-    host_ = new MockMediaStreamDispatcherHost(
-        &resource_context_, message_loop_.get(), audio_manager_.get());
+    host_ = new MockMediaStreamDispatcherHost(&resource_context_,
+                                              message_loop_.get());
 
     // Use the fake content client and browser.
     old_client_ = content::GetContentClient();
     old_browser_client_ = content::GetContentClient()->browser();
     content_client_.reset(new TestContentClient);
     content::SetContentClient(content_client_.get());
     content_client_->set_browser_for_testing(host_);
   }
 
   virtual void TearDown() {
     // Needed to make sure the manager finishes all tasks on its own thread.
     SyncWithVideoCaptureManagerThread();
 
     // Recover the old browser client and content client.
     content::GetContentClient()->set_browser_for_testing(old_browser_client_);
     content::SetContentClient(old_client_);
     content_client_.reset();
   }
 
   // Called on the VideoCaptureManager thread.
   static void PostQuitMessageLoop(MessageLoop* message_loop) {
     message_loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   // Called on the main thread.
   static void PostQuitOnVideoCaptureManagerThread(
       MessageLoop* message_loop,
       media_stream::MediaStreamManager* media_stream_manager) {
-    media_stream_manager->video_capture_manager()->GetMessageLoop()->
-        PostTask(FROM_HERE,
-                 base::Bind(&PostQuitMessageLoop, message_loop));
+    media_stream_manager->GetMessageLoop()->PostTask(
+        FROM_HERE, base::Bind(&PostQuitMessageLoop, message_loop));
   }
 
   // SyncWithVideoCaptureManagerThread() waits until all pending tasks on the
   // video_capture_manager thread are executed while also processing pending
   // task in message_loop_ on the current thread. It is used to synchronize
   // with the video capture manager thread when we are stopping a video
   // capture device.
   void SyncWithVideoCaptureManagerThread() {

[scherkus (not reviewing), 2012/06/27 00:52:31]

do you really need to sync here? would the following be equivalent:

message_loop_->RunAllPending();
media_stream_manager_.reset();  // Teardown will finish pending tasks.

that way you don't need the test to peek into the manager's message loop

[no longer working on chromium, 2012/06/27 14:07:16]

I am not familiar with the code here, but the comment in TearDown() clearly
points out that we need to make sure the manager finishes all the task.
And we can't call media_stream_manager_.reset() since media_stream_manager is
owned by the profile and will be deleted when the profile goes away.
Magnus, do you know if message_loop_->RunAllPending() is enough here?

     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&PostQuitOnVideoCaptureManagerThread,
                    message_loop_.get(),
                    MediaStreamManager::GetForResourceContext(
-                       &resource_context_, audio_manager_.get())));
+                       &resource_context_)));
     message_loop_->Run();
   }
 
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   scoped_ptr<MessageLoop> message_loop_;
   scoped_ptr<BrowserThreadImpl> ui_thread_;
   scoped_ptr<BrowserThreadImpl> io_thread_;
-  scoped_ptr<media::AudioManager> audio_manager_;
   content::MockResourceContext resource_context_;
   content::ContentClient* old_client_;
   content::ContentBrowserClient* old_browser_client_;
   scoped_ptr<content::ContentClient> content_client_;
   scoped_ptr<MockMediaObserver> media_observer_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStream) {
   StreamOptions options(false, true);
 
@@ skipping 100 matching lines @@
   EXPECT_CALL(*media_observer_.get(), OnCaptureDevicesOpened(_, _, _));
   WaitForResult();
   std::string label =  host_->label_;
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   EXPECT_EQ(host_->NumberOfStreams(), 1u);
 
   EXPECT_CALL(*host_, OnVideoDeviceFailed(kRenderId, 0));
   int session_id = host_->video_devices_[0].session_id;
-  MediaStreamManager::GetForResourceContext(
-      &resource_context_, audio_manager_.get())->
+  MediaStreamManager::GetForResourceContext(&resource_context_)->
           video_capture_manager()->Error(session_id);

[scherkus (not reviewing), 2012/06/27 00:52:31]

fix indent

[no longer working on chromium, 2012/06/27 14:07:16]

Done.

   WaitForResult();
   EXPECT_EQ(host_->video_devices_.size(), 0u);
   EXPECT_EQ(host_->NumberOfStreams(), 1u);
 
   // TODO(perkj): test audio device failure?
 
   host_->OnStopGeneratedStream(label);
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
 };  // namespace media_stream