Delete MediaStreamManager in the same way as AudioManager

content/browser/renderer_host/media/media_stream_manager.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 "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 44 matching lines @@
     return true;
   }
   return false;
 }
 
 DeviceThread::DeviceThread(const char* name)
     : base::Thread(name) {
 }
 
 DeviceThread::~DeviceThread() {
+  Stop();
 }
 
 void DeviceThread::Init() {
   using base::win::ScopedCOMInitializer;
   // Enter the multi-threaded apartment.
   com_initializer_.reset(new ScopedCOMInitializer(ScopedCOMInitializer::kMTA));
 }
 
 void DeviceThread::CleanUp() {
   com_initializer_.reset();
@@ skipping 55 matching lines @@
   StreamDeviceInfoArray video_devices;
 };
 
 MediaStreamManager::MediaStreamManager(
     AudioInputDeviceManager* audio_input_device_manager,
     VideoCaptureManager* video_capture_manager)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           device_settings_(new MediaStreamDeviceSettings(this))),
       audio_input_device_manager_(audio_input_device_manager),
       video_capture_manager_(video_capture_manager),
-      enumeration_in_progress_(content::NUM_MEDIA_STREAM_DEVICE_TYPES, false) {
+      enumeration_in_progress_(content::NUM_MEDIA_STREAM_DEVICE_TYPES, false),
+      io_loop_(NULL) {
 }
 
 MediaStreamManager::~MediaStreamManager() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (device_thread_.get()) {
-    video_capture_manager_->Unregister();
-    audio_input_device_manager_->Unregister();
-    device_thread_->Stop();
-  }
+  DCHECK(requests_.empty());
+  DCHECK(!device_thread_.get());
+  DCHECK(!io_loop_);
 }
 
 VideoCaptureManager* MediaStreamManager::video_capture_manager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(video_capture_manager_.get());
+  DCHECK(video_capture_manager_);
   EnsureDeviceThreadAndListener();
-  return video_capture_manager_.get();
+  return video_capture_manager_;
 }
 
 AudioInputDeviceManager* MediaStreamManager::audio_input_device_manager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(audio_input_device_manager_.get());
+  DCHECK(audio_input_device_manager_);
   EnsureDeviceThreadAndListener();
-  return audio_input_device_manager_.get();
+  return audio_input_device_manager_;
 }
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_view_id,
                                         const StreamOptions& options,
                                         const GURL& security_origin,
                                         std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
@@ skipping 193 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (device_thread_.get())
     return;
 
   device_thread_.reset(new DeviceThread("MediaStreamDeviceThread"));
   CHECK(device_thread_->Start());
 
   audio_input_device_manager_->Register(this,
                                         device_thread_->message_loop_proxy());
   video_capture_manager_->Register(this, device_thread_->message_loop_proxy());
+
+  // We want to be notified of IO message loop destruction to delete the thread
+  // and the device managers.
+  io_loop_ = MessageLoop::current();
+  io_loop_->AddDestructionObserver(this);
 }
 
 void MediaStreamManager::Opened(MediaStreamType stream_type,
                                 int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Find the request containing this device and mark it as used.
   DeviceRequest* request = NULL;
   StreamDeviceInfoArray* devices = NULL;
   std::string label;
@@ skipping 228 matching lines @@
     return;
   }
 }
 
 void MediaStreamManager::UseFakeDevice() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   video_capture_manager()->UseFakeDevice();
   device_settings_->UseFakeUI();
 }
 
+void MediaStreamManager::WillDestroyCurrentMessageLoop() {
+  DCHECK_EQ(MessageLoop::current(), io_loop_);
+  if (device_thread_.get()) {
+    video_capture_manager_->Unregister();
+    audio_input_device_manager_->Unregister();
+    device_thread_.reset();
+  }
+
+  audio_input_device_manager_ = NULL;
+  video_capture_manager_ = NULL;
+  io_loop_ = NULL;
+  device_settings_.reset();
+}
+
 void MediaStreamManager::NotifyObserverDevicesOpened(DeviceRequest* request) {
   content::MediaObserver* media_observer =
       content::GetContentClient()->browser()->GetMediaObserver();
   content::MediaStreamDevices opened_devices;
   DevicesFromRequest(request, &opened_devices);
   DCHECK(!opened_devices.empty());
   media_observer->OnCaptureDevicesOpened(request->render_process_id,
                                          request->render_view_id,
                                          opened_devices);
 }
@@ skipping 62 matching lines @@
   if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE) {
     return video_capture_manager();
   } else if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE) {
     return audio_input_device_manager();
   }
   NOTREACHED();
   return NULL;
 }
 
 }  // namespace media_stream