Removing singleton property of MediaStreamManager and creating thread first when needed.

content/browser/renderer_host/media/video_capture_host_unittest.cc

 // Copyright (c) 2011 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 <map>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_host.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
+#include "content/browser/resource_context.h"
 #include "content/common/media/video_capture_messages.h"
 #include "media/video/capture/video_capture_types.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::AnyNumber;
 using ::testing::DoAll;
@@ skipping 32 matching lines @@
     if (file_.get() != NULL) {
       fwrite(buffer, expected_size_, 1, file_.get());
     }
   }
 
  private:
   file_util::ScopedFILE file_;
   int expected_size_;
 };
 
+namespace content {
+// Test version of ResourceContext
+class MockVideoCaptureResourceContext : public ResourceContext {
+ public:
+  MockVideoCaptureResourceContext() {}
+  virtual ~MockVideoCaptureResourceContext() {}
+
+  virtual media_stream::MediaStreamManager* media_stream_manger() const {
+    return media_stream_manager_.get();
+  }
+
+  void set_media_stream_manager(
+      media_stream::MediaStreamManager* media_stream_manager) {
+    media_stream_manager_ = media_stream_manager;
+  }
+
+ private:
+  // Pure virtual in ResourceContext.
+  virtual void EnsureInitialized() const {}
+
+  scoped_refptr<media_stream::MediaStreamManager> media_stream_manager_;
+};
+
+}  // namespace content
+
 class MockVideoCaptureHost : public VideoCaptureHost {
  public:
-  MockVideoCaptureHost() : return_buffers_(false), dump_video_(false) {}
+  explicit MockVideoCaptureHost(content::ResourceContext* resource_context)
+      : VideoCaptureHost(resource_context),
+        return_buffers_(false),
+        dump_video_(false) {}
   virtual ~MockVideoCaptureHost() {
     STLDeleteContainerPairSecondPointers(filled_dib_.begin(),
                                          filled_dib_.end());
   }
 
   // A list of mock methods.
   MOCK_METHOD4(OnNewBufferCreated,
                void(int device_id, base::SharedMemoryHandle handle,
                     int length, int buffer_id));
   MOCK_METHOD3(OnBufferFilled,
@@ skipping 100 matching lines @@
 }
 
 class VideoCaptureHostTest : public testing::Test {
  public:
   VideoCaptureHostTest() {}
 
  protected:
   virtual void SetUp() {
     // Create a message loop so VideoCaptureHostTest can use it.
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
+
+    // ResourceContext must be created on the UI thread.
+    ui_thread_.reset(new BrowserThread(BrowserThread::UI, message_loop_.get()));
+    resource_context_.reset(new content::MockVideoCaptureResourceContext());
+
+    // MediaStreamManager must be created on the IO thread.
     io_thread_.reset(new BrowserThread(BrowserThread::IO, message_loop_.get()));
+
+    // Create a MediaStreamManager ad hand over ownership to ResourceContext.
+    media_stream::MediaStreamManager* media_stream_manager =
+        new media_stream::MediaStreamManager();
+    resource_context_->set_media_stream_manager(media_stream_manager);
+
     // Setup the VideoCaptureManager to use fake video capture device.
 #ifndef TEST_REAL_CAPTURE_DEVICE
-    media_stream::VideoCaptureManager* manager =
-        media_stream::MediaStreamManager::Get()->video_capture_manager();
-    manager->UseFakeDevice();
+    resource_context_->media_stream_manager()->video_capture_manager()->
+        UseFakeDevice();
 #endif
-    host_ = new MockVideoCaptureHost();
+    host_ = new MockVideoCaptureHost(resource_context_.get());
 
     // Simulate IPC channel connected.
     host_->OnChannelConnected(base::GetCurrentProcId());
   }
 
   virtual void TearDown() {
     // Verifies and removes the expectations on host_ and
     // returns true iff successful.
     Mock::VerifyAndClearExpectations(host_);
 
     EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
                                        media::VideoCapture::kStopped))
         .Times(AnyNumber());
 
     // 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.
     SyncWithVideoCaptureManagerThread();
 
     io_thread_.reset();
+    ui_thread_.reset();
   }
 
   // Called on the VideoCaptureManager thread.
   static void PostQuitMessageLoop(MessageLoop* message_loop) {
     message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   }
 
   // Called on the main thread.
-  static void PostQuitOnVideoCaptureManagerThread(MessageLoop* message_loop) {
-    media_stream::MediaStreamManager::Get()->video_capture_manager()->
+  static void PostQuitOnVideoCaptureManagerThread(
+      MessageLoop* message_loop, content::ResourceContext* resource_context) {
+    resource_context->media_stream_manager()->video_capture_manager()->
         GetMessageLoop()->PostTask(FROM_HERE,
                                    NewRunnableFunction(
                                        &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() {
     message_loop_->PostTask(
         FROM_HERE, NewRunnableFunction(&PostQuitOnVideoCaptureManagerThread,
-                                       message_loop_.get()));
+                                       message_loop_.get(),
+                                       resource_context_.get()));
     message_loop_->Run();
   }
 
   void StartCapture() {
     InSequence s;
     // 1. Newly created buffers will arrive.
     EXPECT_CALL(*host_, OnNewBufferCreated(kDeviceId, _, _, _))
         .Times(AnyNumber())
         .WillRepeatedly(Return());
 
@@ skipping 75 matching lines @@
                                        media::VideoCapture::kError))
         .Times(1);
     VideoCaptureControllerID id(kDeviceId);
     host_->OnError(id);
     SyncWithVideoCaptureManagerThread();
   }
 
   scoped_refptr<MockVideoCaptureHost> host_;
  private:
   scoped_ptr<MessageLoop> message_loop_;
+  scoped_ptr<BrowserThread> ui_thread_;
   scoped_ptr<BrowserThread> io_thread_;
+  scoped_ptr<content::ResourceContext> resource_context_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHostTest);
 };
 
 TEST_F(VideoCaptureHostTest, StartCapture) {
   StartCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCapturePlayStop) {
   StartCapture();
@@ skipping 20 matching lines @@
 }
 
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif