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

Most likely cause of new Flakiness in PrerenderBrowserTest.PrerenderUnload...

BUG=92125
TEST=

Review URL: http://codereview.chromium.org/7649016

TBR=mflodman@chromium.org
Review URL: http://codereview.chromium.org/7885034

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@101107 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 91 insertions, 195 deletions

diff --git a/content/browser/renderer_host/browser_render_process_host.cc b/content/browser/renderer_host/browser_render_process_host.cc
index b9bb664..e863591 100644
--- a/content/browser/renderer_host/browser_render_process_host.cc
+++ b/content/browser/renderer_host/browser_render_process_host.cc
@@ -361,8 +361,7 @@ void BrowserRenderProcessHost::CreateMessageFilters() {
   channel_->AddFilter(new AudioInputRendererHost());
   channel_->AddFilter(
       new AudioRendererHost(&browser_context()->GetResourceContext()));
-  channel_->AddFilter(
-      new VideoCaptureHost(&browser_context()->GetResourceContext()));
+  channel_->AddFilter(new VideoCaptureHost());
   channel_->AddFilter(
       new AppCacheDispatcherHost(browser_context()->GetAppCacheService(),
                                  id()));
@@ -375,8 +374,7 @@ void BrowserRenderProcessHost::CreateMessageFilters() {
       GeolocationDispatcherHost::New(
           id(), browser_context()->GetGeolocationPermissionContext()));
   channel_->AddFilter(new GpuMessageFilter(id(), widget_helper_.get()));
-  channel_->AddFilter(new media_stream::MediaStreamDispatcherHost(
-      &browser_context()->GetResourceContext(), id()));
+  channel_->AddFilter(new media_stream::MediaStreamDispatcherHost(id()));
   channel_->AddFilter(new PepperFileMessageFilter(id(), browser_context()));
   channel_->AddFilter(
       new PepperMessageFilter(&browser_context()->GetResourceContext()));
diff --git a/content/browser/renderer_host/media/media_stream_dispatcher_host.cc b/content/browser/renderer_host/media/media_stream_dispatcher_host.cc
index 9272a7d..9f7ddb7 100644
--- a/content/browser/renderer_host/media/media_stream_dispatcher_host.cc
+++ b/content/browser/renderer_host/media/media_stream_dispatcher_host.cc
@@ -4,23 +4,20 @@
 
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 
-#include "content/browser/resource_context.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
 
 namespace media_stream {
 
-MediaStreamDispatcherHost::MediaStreamDispatcherHost(
-    const content::ResourceContext* resource_context, int render_process_id)
-    : resource_context_(resource_context),
-      render_process_id_(render_process_id) {
+MediaStreamDispatcherHost::MediaStreamDispatcherHost(int render_process_id)
+    : render_process_id_(render_process_id) {
 }
 
 MediaStreamDispatcherHost::~MediaStreamDispatcherHost() {
 }
 
 MediaStreamManager* MediaStreamDispatcherHost::manager() {
-  return resource_context_->media_stream_manager();
+  return MediaStreamManager::Get();
 }
 
 bool MediaStreamDispatcherHost::OnMessageReceived(
diff --git a/content/browser/renderer_host/media/media_stream_dispatcher_host.h b/content/browser/renderer_host/media/media_stream_dispatcher_host.h
index c02d675..3951339 100644
--- a/content/browser/renderer_host/media/media_stream_dispatcher_host.h
+++ b/content/browser/renderer_host/media/media_stream_dispatcher_host.h
@@ -14,10 +14,6 @@
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/common/media/media_stream_options.h"
 
-namespace content {
-class ResourceContext;
-}  // namespace content
-
 namespace media_stream {
 
 // MediaStreamDispatcherHost is a delegate for Media Stream API messages used by
@@ -27,8 +23,7 @@ class MediaStreamDispatcherHost
     : public BrowserMessageFilter,
       public MediaStreamRequester {
  public:
-  MediaStreamDispatcherHost(const content::ResourceContext* resource_context,
-                            int render_process_id);
+  explicit MediaStreamDispatcherHost(int render_process_id);
   virtual ~MediaStreamDispatcherHost();
 
   // MediaStreamRequester implementation.
@@ -59,9 +54,7 @@ class MediaStreamDispatcherHost
   // creating one if needed.
   MediaStreamManager* manager();
 
-  const content::ResourceContext* resource_context_;
   int render_process_id_;
-
   struct StreamRequest {
     StreamRequest() {}
     StreamRequest(int render_view_id, int page_request_id)
diff --git a/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc b/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc
index cb311f3..76eef56 100644
--- a/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc
+++ b/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc
@@ -5,11 +5,9 @@
 #include <string>
 
 #include "base/message_loop.h"
-#include "content/browser/mock_resource_context.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/video_capture_manager.h"
-#include "content/browser/resource_context.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
 #include "ipc/ipc_message_macros.h"
@@ -29,9 +27,8 @@ namespace media_stream {
 
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost {
  public:
-  MockMediaStreamDispatcherHost(content::ResourceContext* resource_context,
-                                MessageLoop* message_loop)
-      : MediaStreamDispatcherHost(resource_context, kProcessId),
+  explicit MockMediaStreamDispatcherHost(MessageLoop* message_loop)
+      : MediaStreamDispatcherHost(kProcessId),
         message_loop_(message_loop) {}
   virtual ~MockMediaStreamDispatcherHost() {}
 
@@ -44,7 +41,9 @@ class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost {
   MOCK_METHOD2(OnVideoDeviceFailed, void(int routing_id, int index));
 
   // Accessor to private functions.
-  void OnGenerateStream(int page_request_id, const StreamOptions& components) {
+  void OnGenerateStream(
+      int page_request_id,
+      const StreamOptions& components) {
     MediaStreamDispatcherHost::OnGenerateStream(kRenderId,
                                                 page_request_id,
                                                 components,
@@ -105,7 +104,8 @@ class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost {
     video_devices_ = video_device_list;
   }
 
-  void OnStreamGenerationFailed(const IPC::Message& msg, int request_id) {
+  void OnStreamGenerationFailed(const IPC::Message& msg,
+                                int request_id) {
     OnStreamGenerationFailed(msg.routing_id(), request_id);
     message_loop_->PostTask(FROM_HERE, new MessageLoop::QuitTask());
     label_= "";
@@ -138,64 +138,23 @@ class MediaStreamDispatcherHostTest : public testing::Test {
 
  protected:
   virtual void SetUp() {
+    // Create message loop so that
+    // DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)) passes.
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
-    // ResourceContext must be created on UI thread.
-    ui_thread_.reset(new BrowserThread(BrowserThread::UI, message_loop_.get()));
-    // MediaStreamManager must be created and called on IO thread.
     io_thread_.reset(new BrowserThread(BrowserThread::IO, message_loop_.get()));
 
-    // Create a MediaStreamManager instance and hand over pointer to
-    // ResourceContext.
-    media_stream_manager_.reset(new MediaStreamManager());
-    // Make sure we use fake devices to avoid long delays.
-    media_stream_manager_->UseFakeDevice();
-    content::MockResourceContext::GetInstance()->set_media_stream_manager(
-        media_stream_manager_.get());
+    // Make sure the MediaStreamManager exist and use
+    // fake audio / video devices.
+    MediaStreamManager* manager = MediaStreamManager::Get();
+    manager->UseFakeDevice();
 
-    host_ = new MockMediaStreamDispatcherHost(
-        content::MockResourceContext::GetInstance(), message_loop_.get());
-  }
-
-  virtual void TearDown() {
-    content::MockResourceContext::GetInstance()->set_media_stream_manager(NULL);
-
-    // Needed to make sure the manager finishes all tasks on its own thread.
-    SyncWithVideoCaptureManagerThread();
-  }
-
-  // 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* media_stream_manager) {
-    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(),
-                            media_stream_manager_.get()));
-    message_loop_->Run();
+    host_ =
+        new MockMediaStreamDispatcherHost(message_loop_.get());
   }
 
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   scoped_ptr<MessageLoop> message_loop_;
-  scoped_ptr<BrowserThread> ui_thread_;
   scoped_ptr<BrowserThread> io_thread_;
-  scoped_ptr<MediaStreamManager> media_stream_manager_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStream) {
@@ -264,8 +223,7 @@ TEST_F(MediaStreamDispatcherHostTest, FailDevice) {
 
   EXPECT_CALL(*host_, OnVideoDeviceFailed(kRenderId, 0));
   int session_id = host_->video_devices_[0].session_id;
-  content::MockResourceContext::GetInstance()->media_stream_manager()->
-      video_capture_manager()->Error(session_id);
+  MediaStreamManager::Get()->video_capture_manager()->Error(session_id);
   WaitForResult();
   EXPECT_EQ(host_->video_devices_.size(), 0u);
   EXPECT_EQ(host_->NumberOfStreams(), 1u);
diff --git a/content/browser/renderer_host/media/media_stream_manager.cc b/content/browser/renderer_host/media/media_stream_manager.cc
index 8f17b54..786cb26 100644
--- a/content/browser/renderer_host/media/media_stream_manager.cc
+++ b/content/browser/renderer_host/media/media_stream_manager.cc
@@ -6,7 +6,7 @@
 
 #include <list>
 
-#include "base/compiler_specific.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "content/browser/browser_thread.h"
@@ -17,9 +17,13 @@
 
 namespace media_stream {
 
+// TODO(mflodman) Find out who should own MediaStreamManager.
+base::LazyInstance<MediaStreamManager> g_media_stream_manager(
+    base::LINKER_INITIALIZED);
+
 // Creates a random label used to identify requests.
 static std::string RandomLabel() {
-  // Alphabet according to WhatWG standard, i.e. containing 36 characters from
+  // Alphbet according to WhatWG standard, i.e. containing 36 characters from
   // range: U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E,
   // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E.
   static const char alphabet[] = "!#$%&\'*+-.0123456789"
@@ -45,24 +49,18 @@ static bool Requested(const StreamOptions& options,
   return false;
 }
 
-MediaStreamManager::MediaStreamManager()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(
-          device_settings_(new MediaStreamDeviceSettings(this))),
-      enumeration_in_progress_(kNumMediaStreamTypes, false) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+MediaStreamManager* MediaStreamManager::Get() {
+  return g_media_stream_manager.Pointer();
 }
 
 MediaStreamManager::~MediaStreamManager() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  delete device_settings_;
+  delete video_capture_manager_;
 }
 
 VideoCaptureManager* MediaStreamManager::video_capture_manager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (!video_capture_manager_.get()) {
-    video_capture_manager_.reset(new VideoCaptureManager());
-    video_capture_manager_->Register(this);
-  }
-  return video_capture_manager_.get();
+  return video_capture_manager_;
 }
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
@@ -122,7 +120,7 @@ void MediaStreamManager::CancelRequests(MediaStreamRequester* requester) {
              request->video_devices.begin(); it != request->video_devices.end();
              ++it) {
           if (it->in_use == true) {
-            video_capture_manager()->Close(it->session_id);
+            video_capture_manager_->Close(it->session_id);
           }
         }
       }
@@ -147,7 +145,7 @@ void MediaStreamManager::StopGeneratedStream(const std::string& label) {
     for (StreamDeviceInfoArray::iterator video_it =
          it->second.video_devices.begin();
          video_it != it->second.video_devices.end(); ++video_it) {
-      video_capture_manager()->Close(video_it->session_id);
+      video_capture_manager_->Close(video_it->session_id);
     }
     requests_.erase(it);
     return;
@@ -356,7 +354,7 @@ void MediaStreamManager::SettingsError(const std::string& label) {
 
 void MediaStreamManager::UseFakeDevice() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  video_capture_manager()->UseFakeDevice();
+  video_capture_manager_->UseFakeDevice();
   device_settings_->UseFakeUI();
   // TODO(mflodman) Add audio manager when available.
 }
@@ -387,9 +385,9 @@ bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
 
 // Called to get media capture device manager of specified type.
 MediaStreamProvider* MediaStreamManager::GetDeviceManager(
-    MediaStreamType stream_type) {
+    MediaStreamType stream_type) const {
   if (stream_type == kVideoCapture) {
-    return video_capture_manager();
+    return video_capture_manager_;
   } else if (stream_type == kAudioCapture) {
     // TODO(mflodman) Add support when audio input manager is available.
     NOTREACHED();
@@ -399,6 +397,16 @@ MediaStreamProvider* MediaStreamManager::GetDeviceManager(
   return NULL;
 }
 
+MediaStreamManager::MediaStreamManager()
+    : video_capture_manager_(new VideoCaptureManager()),
+      enumeration_in_progress_(kNumMediaStreamTypes, false),
+      requests_(),
+      device_settings_(NULL) {
+  device_settings_ = new MediaStreamDeviceSettings(this);
+  video_capture_manager_->Register(this);
+  // TODO(mflodman) Add when audio input manager is available.
+}
+
 MediaStreamManager::DeviceRequest::DeviceRequest()
     : requester(NULL),
       state(kNumMediaStreamTypes, kNotRequested) {
diff --git a/content/browser/renderer_host/media/media_stream_manager.h b/content/browser/renderer_host/media/media_stream_manager.h
index 50a28d5..f5792ce 100644
--- a/content/browser/renderer_host/media/media_stream_manager.h
+++ b/content/browser/renderer_host/media/media_stream_manager.h
@@ -23,8 +23,7 @@
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/lazy_instance.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/browser/renderer_host/media/media_stream_settings_requester.h"
 #include "content/common/media/media_stream_options.h"
@@ -43,10 +42,11 @@ class MediaStreamManager
     : public MediaStreamProviderListener,
       public SettingsRequester {
  public:
-  MediaStreamManager();
+  typedef MediaStreamManager* (AccessorMethod)();
+  static MediaStreamManager* Get();
   virtual ~MediaStreamManager();
 
-  // Used to access VideoCaptureManager.
+  // Used to access VideoCaptuerManager.
   VideoCaptureManager* video_capture_manager();
 
   // GenerateStream opens new media devices according to |components|. The
@@ -106,10 +106,13 @@ class MediaStreamManager
 
   // Helpers.
   bool RequestDone(const MediaStreamManager::DeviceRequest& request) const;
-  MediaStreamProvider* GetDeviceManager(MediaStreamType stream_type);
+  MediaStreamProvider* GetDeviceManager(MediaStreamType stream_type) const;
+
+  // Private constructor to enforce singleton.
+  friend struct base::DefaultLazyInstanceTraits<MediaStreamManager>;
+  MediaStreamManager();
 
-  scoped_ptr<MediaStreamDeviceSettings> device_settings_;
-  scoped_ptr<VideoCaptureManager> video_capture_manager_;
+  VideoCaptureManager* video_capture_manager_;
   // TODO(mflodman) Add AudioInputManager.
 
   // Keeps track of device types currently being enumerated to not enumerate
@@ -120,6 +123,8 @@ class MediaStreamManager
   typedef std::map<std::string, DeviceRequest> DeviceRequests;
   DeviceRequests requests_;
 
+  MediaStreamDeviceSettings* device_settings_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaStreamManager);
 };
 
diff --git a/content/browser/renderer_host/media/video_capture_controller.cc b/content/browser/renderer_host/media/video_capture_controller.cc
index 82dbabb..bdad7e0 100644
--- a/content/browser/renderer_host/media/video_capture_controller.cc
+++ b/content/browser/renderer_host/media/video_capture_controller.cc
@@ -16,13 +16,11 @@ static const size_t kNoOfDIBS = 3;
 VideoCaptureController::VideoCaptureController(
     const VideoCaptureControllerID& id,
     base::ProcessHandle render_process,
-    VideoCaptureControllerEventHandler* event_handler,
-    media_stream::VideoCaptureManager* video_capture_manager)
+    VideoCaptureControllerEventHandler* event_handler)
     : render_handle_(render_process),
       report_ready_to_delete_(false),
       event_handler_(event_handler),
-      id_(id),
-      video_capture_manager_(video_capture_manager) {
+      id_(id) {
   memset(&params_, 0, sizeof(params_));
 }
 
@@ -37,18 +35,21 @@ void VideoCaptureController::StartCapture(
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   params_ = params;
+    media_stream::VideoCaptureManager* manager =
+        media_stream::MediaStreamManager::Get()->video_capture_manager();
   // Order the manager to start the actual capture.
-  video_capture_manager_->Start(params, this);
+  manager->Start(params, this);
 }
 
 void VideoCaptureController::StopCapture(Task* stopped_task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  video_capture_manager_->Stop(
-      params_.session_id,
-      NewRunnableMethod(this,
-                        &VideoCaptureController::OnDeviceStopped,
-                        stopped_task));
+  media_stream::VideoCaptureManager* manager =
+      media_stream::MediaStreamManager::Get()->video_capture_manager();
+  manager->Stop(params_.session_id,
+                NewRunnableMethod(this,
+                                  &VideoCaptureController::OnDeviceStopped,
+                                  stopped_task));
 }
 
 void VideoCaptureController::ReturnBuffer(int buffer_id) {
@@ -157,7 +158,8 @@ void VideoCaptureController::OnIncomingCapturedFrame(const uint8* data,
 
 void VideoCaptureController::OnError() {
   event_handler_->OnError(id_);
-  video_capture_manager_->Error(params_.session_id);
+  media_stream::MediaStreamManager::Get()->video_capture_manager()->
+      Error(params_.session_id);
 }
 
 void VideoCaptureController::OnFrameInfo(
diff --git a/content/browser/renderer_host/media/video_capture_controller.h b/content/browser/renderer_host/media/video_capture_controller.h
index 0c760cb..432ac4a 100644
--- a/content/browser/renderer_host/media/video_capture_controller.h
+++ b/content/browser/renderer_host/media/video_capture_controller.h
@@ -27,19 +27,13 @@
 #include "media/video/capture/video_capture_types.h"
 #include "ui/gfx/surface/transport_dib.h"
 
-namespace media_stream {
-class VideoCaptureManager;
-}  // namespace media_stream
-
 class VideoCaptureController
     : public base::RefCountedThreadSafe<VideoCaptureController>,
       public media::VideoCaptureDevice::EventHandler {
  public:
-  VideoCaptureController(
-      const VideoCaptureControllerID& id,
-      base::ProcessHandle render_process,
-      VideoCaptureControllerEventHandler* event_handler,
-      media_stream::VideoCaptureManager* video_capture_manager);
+  VideoCaptureController(const VideoCaptureControllerID& id,
+                         base::ProcessHandle render_process,
+                         VideoCaptureControllerEventHandler* event_handler);
   virtual ~VideoCaptureController();
 
   // Starts video capturing and tries to use the resolution specified in
@@ -93,8 +87,6 @@ class VideoCaptureController
   VideoCaptureControllerID id_;
   media::VideoCaptureDevice::Capability frame_info_;
 
-  media_stream::VideoCaptureManager* video_capture_manager_;
-
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoCaptureController);
 };
 
diff --git a/content/browser/renderer_host/media/video_capture_host.cc b/content/browser/renderer_host/media/video_capture_host.cc
index 65be7a3..d3192d6 100644
--- a/content/browser/renderer_host/media/video_capture_host.cc
+++ b/content/browser/renderer_host/media/video_capture_host.cc
@@ -6,14 +6,9 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
-#include "content/browser/renderer_host/media/media_stream_manager.h"
-#include "content/browser/resource_context.h"
 #include "content/common/media/video_capture_messages.h"
 
-VideoCaptureHost::VideoCaptureHost(
-    const content::ResourceContext* resource_context)
-    : resource_context_(resource_context) {
-}
+VideoCaptureHost::VideoCaptureHost() {}
 
 VideoCaptureHost::~VideoCaptureHost() {}
 
@@ -152,9 +147,7 @@ void VideoCaptureHost::OnStartCapture(int device_id,
   DCHECK(entries_.find(controller_id) == entries_.end());
 
   scoped_refptr<VideoCaptureController> controller =
-      new VideoCaptureController(
-          controller_id, peer_handle(), this,
-          resource_context_->media_stream_manager()->video_capture_manager());
+      new VideoCaptureController(controller_id, peer_handle(), this);
   entries_.insert(std::make_pair(controller_id, controller));
   controller->StartCapture(params);
 }
diff --git a/content/browser/renderer_host/media/video_capture_host.h b/content/browser/renderer_host/media/video_capture_host.h
index e0c0869..335ee4b 100644
--- a/content/browser/renderer_host/media/video_capture_host.h
+++ b/content/browser/renderer_host/media/video_capture_host.h
@@ -43,15 +43,11 @@
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "ipc/ipc_message.h"
 
-namespace content {
-class ResourceContext;
-}  // namespace content
-
 class VideoCaptureHost
     : public BrowserMessageFilter,
       public VideoCaptureControllerEventHandler {
  public:
-  VideoCaptureHost(const content::ResourceContext* resource_context);
+  VideoCaptureHost();
 
   // BrowserMessageFilter implementation.
   virtual void OnChannelClosing();
@@ -131,9 +127,6 @@ class VideoCaptureHost
   // objects that is currently active.
   EntryMap entries_;
 
-  // Used to get a pointer to VideoCaptureManager to start/stop capture devices.
-  const content::ResourceContext* resource_context_;
-
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHost);
 };
 
diff --git a/content/browser/renderer_host/media/video_capture_host_unittest.cc b/content/browser/renderer_host/media/video_capture_host_unittest.cc
index 8ab1098..e80266a 100644
--- a/content/browser/renderer_host/media/video_capture_host_unittest.cc
+++ b/content/browser/renderer_host/media/video_capture_host_unittest.cc
@@ -12,11 +12,9 @@
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "content/browser/browser_thread.h"
-#include "content/browser/mock_resource_context.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"
 
@@ -68,10 +66,7 @@ class DumpVideo {
 
 class MockVideoCaptureHost : public VideoCaptureHost {
  public:
-  explicit MockVideoCaptureHost(content::ResourceContext* resource_context)
-      : VideoCaptureHost(resource_context),
-        return_buffers_(false),
-        dump_video_(false) {}
+  MockVideoCaptureHost() : return_buffers_(false), dump_video_(false) {}
   virtual ~MockVideoCaptureHost() {
     STLDeleteContainerPairSecondPointers(filled_dib_.begin(),
                                          filled_dib_.end());
@@ -192,25 +187,14 @@ class VideoCaptureHostTest : public testing::Test {
   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()));
-
-    // MediaStreamManager must be created on the IO thread.
     io_thread_.reset(new BrowserThread(BrowserThread::IO, message_loop_.get()));
-
-    // Create a MediaStreamManager instance and hand over pointer to
-    // ResourceContext.
-    media_stream_manager_.reset(new media_stream::MediaStreamManager());
-
+    // Setup the VideoCaptureManager to use fake video capture device.
 #ifndef TEST_REAL_CAPTURE_DEVICE
-    media_stream_manager_->UseFakeDevice();
+    media_stream::VideoCaptureManager* manager =
+        media_stream::MediaStreamManager::Get()->video_capture_manager();
+    manager->UseFakeDevice();
 #endif
-
-    content::MockResourceContext::GetInstance()->set_media_stream_manager(
-        media_stream_manager_.get());
-    host_ = new MockVideoCaptureHost(
-        content::MockResourceContext::GetInstance());
+    host_ = new MockVideoCaptureHost();
 
     // Simulate IPC channel connected.
     host_->OnChannelConnected(base::GetCurrentProcId());
@@ -235,7 +219,7 @@ class VideoCaptureHostTest : public testing::Test {
     // We need to continue running message_loop_ to complete all destructions.
     SyncWithVideoCaptureManagerThread();
 
-    content::MockResourceContext::GetInstance()->set_media_stream_manager(NULL);
+    io_thread_.reset();
   }
 
   // Called on the VideoCaptureManager thread.
@@ -244,9 +228,8 @@ class VideoCaptureHostTest : public testing::Test {
   }
 
   // Called on the main thread.
-  static void PostQuitOnVideoCaptureManagerThread(
-      MessageLoop* message_loop, content::ResourceContext* resource_context) {
-    resource_context->media_stream_manager()->video_capture_manager()->
+  static void PostQuitOnVideoCaptureManagerThread(MessageLoop* message_loop) {
+    media_stream::MediaStreamManager::Get()->video_capture_manager()->
         GetMessageLoop()->PostTask(FROM_HERE,
                                    NewRunnableFunction(
                                        &PostQuitMessageLoop, message_loop));
@@ -259,10 +242,8 @@ class VideoCaptureHostTest : public testing::Test {
   // capture device.
   void SyncWithVideoCaptureManagerThread() {
     message_loop_->PostTask(
-        FROM_HERE,
-        NewRunnableFunction(&PostQuitOnVideoCaptureManagerThread,
-                            message_loop_.get(),
-                            content::MockResourceContext::GetInstance()));
+        FROM_HERE, NewRunnableFunction(&PostQuitOnVideoCaptureManagerThread,
+                                       message_loop_.get()));
     message_loop_->Run();
   }
 
@@ -358,9 +339,7 @@ class VideoCaptureHostTest : public testing::Test {
   scoped_refptr<MockVideoCaptureHost> host_;
  private:
   scoped_ptr<MessageLoop> message_loop_;
-  scoped_ptr<BrowserThread> ui_thread_;
   scoped_ptr<BrowserThread> io_thread_;
-  scoped_ptr<media_stream::MediaStreamManager> media_stream_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHostTest);
 };
diff --git a/content/browser/resource_context.cc b/content/browser/resource_context.cc
index f366242..bc3c6d6 100644
--- a/content/browser/resource_context.cc
+++ b/content/browser/resource_context.cc
@@ -20,8 +20,7 @@ ResourceContext::ResourceContext()
       blob_storage_context_(NULL),
       quota_manager_(NULL),
       host_zoom_map_(NULL),
-      media_observer_(NULL),
-      media_stream_manager_(NULL) {
+      media_observer_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
@@ -153,19 +152,6 @@ void ResourceContext::set_media_observer(MediaObserver* media_observer) {
   media_observer_ = media_observer;
 }
 
-media_stream::MediaStreamManager*
-ResourceContext::media_stream_manager() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  EnsureInitialized();
-  return media_stream_manager_;
-}
-
-void ResourceContext::set_media_stream_manager(
-    media_stream::MediaStreamManager* media_stream_manager) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  media_stream_manager_ = media_stream_manager;
-}
-
 const base::Callback<prerender::PrerenderManager*(void)>&
 ResourceContext::prerender_manager_getter() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
diff --git a/content/browser/resource_context.h b/content/browser/resource_context.h
index 0c8ad77..f53de50 100644
--- a/content/browser/resource_context.h
+++ b/content/browser/resource_context.h
@@ -20,9 +20,6 @@ class MediaObserver;
 namespace fileapi {
 class FileSystemContext;
 }  // namespace fileapi
-namespace media_stream {
-class MediaStreamManager;
-}  // namespace media_stream
 namespace net {
 class HostResolver;
 class URLRequestContext;
@@ -79,10 +76,6 @@ class CONTENT_EXPORT ResourceContext {
   MediaObserver* media_observer() const;
   void set_media_observer(MediaObserver* media_observer);
 
-  media_stream::MediaStreamManager* media_stream_manager() const;
-  void set_media_stream_manager(
-      media_stream::MediaStreamManager* media_stream_manager);
-
   // =======================================================================
   // TODO(willchan): These don't belong in content/. Remove them eventually.
 
@@ -108,7 +101,6 @@ class CONTENT_EXPORT ResourceContext {
   quota::QuotaManager* quota_manager_;
   HostZoomMap* host_zoom_map_;
   MediaObserver* media_observer_;
-  media_stream::MediaStreamManager* media_stream_manager_;
 
   // Externally-defined data accessible by key.
   typedef std::map<const void*, void*> UserDataMap;