Re-added OnChannelClosing in MediaStreamDispatcherHost to close open media devices.

content/browser/renderer_host/media/video_capture_manager.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 "content/browser/renderer_host/media/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
@@ skipping 29 matching lines @@
 
 VideoCaptureManager::VideoCaptureManager()
   : vc_device_thread_("VideoCaptureManagerThread"),
     listener_(NULL),
     new_capture_session_id_(kFirstSessionId),
     use_fake_device_(false) {
   vc_device_thread_.Start();
 }
 
 VideoCaptureManager::~VideoCaptureManager() {
-  // TODO(mflodman) Remove this temporary solution when shut-down issue is
-  // resolved, i.e. all code below this comment.
-  // Temporary solution: close all open devices and delete them, after the
-  // thread is stopped.
-  DLOG_IF(ERROR, !devices_.empty()) << "VideoCaptureManager: Open devices!";
+  DCHECK(devices_.empty());
+
+  // TODO(mflodman) Remove this temporary solution when all controllers are
+  // guaranteed to be deleted before the destructor is called.
   listener_ = NULL;
-  // The devices must be stopped on the device thread to avoid threading issues
-  // in native device code.
   vc_device_thread_.message_loop()->PostTask(

[mflodman_chromium_OOO, 2012/02/10 13:24:41]

There is a case when |controllers_| won't be empty here. I'll make a follow up
CL for that as soon as this CL committed, rather than making that fix here.

       FROM_HERE,
       base::Bind(&VideoCaptureManager::TerminateOnDeviceThread,
                  base::Unretained(this)));
   vc_device_thread_.Stop();
 }
 
 void VideoCaptureManager::Register(MediaStreamProviderListener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!listener_);
   listener_ = listener;
@@ skipping 123 matching lines @@
   }
 
   devices_[capture_session_id] = video_capture_device;
   PostOnOpened(capture_session_id);
 }
 
 void VideoCaptureManager::OnClose(int capture_session_id) {
   DCHECK(IsOnCaptureDeviceThread());
 
   media::VideoCaptureDevice* video_capture_device = NULL;
-  VideoCaptureDevices::iterator it = devices_.find(capture_session_id);
-  if (it != devices_.end()) {
-    video_capture_device = it->second;
-    devices_.erase(it);
+  VideoCaptureDevices::iterator device_it = devices_.find(capture_session_id);
+  if (device_it != devices_.end()) {
+    video_capture_device = device_it->second;
+    devices_.erase(device_it);
+    if (!DeviceInUse(video_capture_device)) {
+      // No other users of this device, deallocate (if not done already) and
+      // delete the device. No need to take care of the controller, that is done
+      // by |OnStop|.
+      video_capture_device->DeAllocate();
+      delete video_capture_device;
+    }
   }
-  if (video_capture_device && !DeviceInUse(video_capture_device)) {
-    // Deallocate (if not done already) and delete the device.
-    video_capture_device->DeAllocate();
-    delete video_capture_device;
-  }
-
   PostOnClosed(capture_session_id);
 }
 
 void VideoCaptureManager::OnStart(
     const media::VideoCaptureParams capture_params,
     media::VideoCaptureDevice::EventHandler* video_capture_receiver) {
   DCHECK(IsOnCaptureDeviceThread());
   DCHECK(video_capture_receiver != NULL);
 
   media::VideoCaptureDevice* video_capture_device =
@@ skipping 276 matching lines @@
     VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
     if (dit != devices_.end()) {
       return dit->second;
     }
   }
   return NULL;
 }
 
 void VideoCaptureManager::TerminateOnDeviceThread() {
   DCHECK(IsOnCaptureDeviceThread());
-
-  std::set<media::VideoCaptureDevice*> devices_to_delete;
-  for (VideoCaptureDevices::iterator it = devices_.begin();
-       it != devices_.end(); ++it) {
-    it->second->DeAllocate();
-    devices_to_delete.insert(it->second);
-  }
-  STLDeleteElements(&devices_to_delete);
   STLDeleteValues(&controllers_);
 }
 
 }  // namespace media_stream