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

content/browser/renderer_host/media/video_capture_manager_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.
 
 // Unit test for VideoCaptureManager.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
@@ skipping 55 matching lines @@
  public:
   virtual void OnError() {}
   void OnFrameInfo(const media::VideoCaptureCapability& info) {}
   virtual void OnIncomingCapturedFrame(const uint8* data, int length,
                                        base::Time timestamp) {}
 };
 
 // Test class
 class VideoCaptureManagerTest : public testing::Test {
  public:
-  VideoCaptureManagerTest()
-      : vcm_(),
-        listener_(),
-        message_loop_(),
-        io_thread_(),
-        frame_observer_() {
-  }
+  VideoCaptureManagerTest() {}
   virtual ~VideoCaptureManagerTest() {}
 
  protected:
   virtual void SetUp() {
     listener_.reset(new media_stream::MockMediaStreamProviderListener());
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
     io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
                                            message_loop_.get()));
-    vcm_ = new media_stream::VideoCaptureManager();
+    device_thread_.reset(new base::Thread("VideoCaptureManagerTestThread"));
+    CHECK(device_thread_->Start());
+    vcm_ = new media_stream::VideoCaptureManager(
+        device_thread_->message_loop_proxy());
     vcm_->UseFakeDevice();
     vcm_->Register(listener_.get());
     frame_observer_.reset(new MockFrameObserver());
   }
 
   virtual void TearDown() {
     io_thread_.reset();
+    device_thread_->Stop();

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

nit: should we be stopping/resetting the threads in the reverse order? i.e., in
SetUp() you create the io_thread_ before device_thread_

alternatively you can remove the io_thread_.reset() call, similar to
video_capture_controller_unittest.cc

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

I will remove the device_thread_ here and inject the message_loop to
VideoCaptureManager instead, exactly the same as how we do it in
AudioInputDeviceManager, so that we can skip the syncing of threads.

   }
 
   // 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::VideoCaptureManager* vcm) {
-    vcm->GetMessageLoop()->PostTask(
+      MessageLoop* message_loop, MessageLoop* device_message_loop) {
+    device_message_loop->PostTask(
         FROM_HERE, base::Bind(&PostQuitMessageLoop, message_loop));
   }
 
   // SyncWithVideoCaptureManagerThread() waits until all pending tasks on the
   // video_capture_manager internal 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() {
     message_loop_->PostTask(
         FROM_HERE, base::Bind(&PostQuitOnVideoCaptureManagerThread,
                               message_loop_.get(),
-                              vcm_));
+                              device_thread_->message_loop()));
     message_loop_->Run();
   }
   scoped_refptr<media_stream::VideoCaptureManager> vcm_;
   scoped_ptr<media_stream::MockMediaStreamProviderListener> listener_;
   scoped_ptr<MessageLoop> message_loop_;
   scoped_ptr<BrowserThreadImpl> io_thread_;
+  scoped_ptr<base::Thread> device_thread_;
   scoped_ptr<MockFrameObserver> frame_observer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureManagerTest);
 };
 
 // Test cases
 
 // Try to open, start, stop and close a device.
 TEST_F(VideoCaptureManagerTest, CreateAndClose) {
@@ skipping 181 matching lines @@
   // VideoCaptureManager destructor otherwise.
   vcm_->Close(video_session_id);
   vcm_->Stop(video_session_id, base::Closure());
 
   // Wait to check callbacks before removing the listener
   SyncWithVideoCaptureManagerThread();
   vcm_->Unregister();
 }
 
 }  // namespace