Make VideoCaptureController single-threaded and not ref counted.

content/browser/renderer_host/media/video_capture_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/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 19 matching lines @@
 namespace content {
 
 // Starting id for the first capture session.
 // VideoCaptureManager::kStartOpenSessionId is used as default id without
 // explicitly calling open device.
 enum { kFirstSessionId = VideoCaptureManager::kStartOpenSessionId + 1 };
 
 VideoCaptureManager::DeviceEntry::DeviceEntry(
     MediaStreamType stream_type,
     const std::string& id,
-    scoped_refptr<VideoCaptureController> controller)
+    scoped_ptr<VideoCaptureController> controller)
     : stream_type(stream_type),
       id(id),
-      video_capture_controller(controller) {}
+      video_capture_controller(controller.Pass()) {}
 
 VideoCaptureManager::DeviceEntry::~DeviceEntry() {}
 
 VideoCaptureManager::VideoCaptureManager()
     : listener_(NULL),
       new_capture_session_id_(kFirstSessionId),
       use_fake_device_(false) {
 }
 
 VideoCaptureManager::~VideoCaptureManager() {
@@ skipping 78 matching lines @@
   sessions_.erase(session_it);
 }
 
 void VideoCaptureManager::UseFakeDevice() {
   use_fake_device_ = true;
 }
 
 void VideoCaptureManager::DoStartDeviceOnDeviceThread(
     DeviceEntry* entry,
     const media::VideoCaptureCapability& capture_params,
-    media::VideoCaptureDevice::EventHandler* controller_as_handler) {
+    scoped_ptr<media::VideoCaptureDevice::EventHandler> device_client) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(IsOnDeviceThread());
 
   scoped_ptr<media::VideoCaptureDevice> video_capture_device;
   switch (entry->stream_type) {
     case MEDIA_DEVICE_VIDEO_CAPTURE: {
       // We look up the device id from the renderer in our local enumeration
       // since the renderer does not have all the information that might be
       // held in the browser-side VideoCaptureDevice::Name structure.
       media::VideoCaptureDevice::Name* found =
@@ skipping 19 matching lines @@
 #endif  // defined(ENABLE_SCREEN_CAPTURE)
       break;
     }
     default: {
       NOTIMPLEMENTED();
       break;
     }
   }
 
   if (!video_capture_device) {
-    controller_as_handler->OnError();
+    device_client->OnError();
     return;
   }
 
-  // TODO(nick): Merge Allocate() and Start(). http://crbug.com/285562
-  video_capture_device->Allocate(capture_params, controller_as_handler);
-  video_capture_device->Start();
+  video_capture_device->AllocateAndStart(capture_params, device_client.Pass());
   entry->video_capture_device = video_capture_device.Pass();
 }
 
 void VideoCaptureManager::StartCaptureForClient(
     const media::VideoCaptureParams& capture_params,
     base::ProcessHandle client_render_process,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler,
-    base::Callback<void(VideoCaptureController*)> done_cb) {
+    const DoneCB& done_cb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureManager::StartCaptureForClient, ("
          << capture_params.width
          << ", " << capture_params.height
          << ", " << capture_params.frame_rate
          << ", #" << capture_params.session_id
          << ")";
 
   if (capture_params.session_id == kStartOpenSessionId) {
     // Solution for not using MediaStreamManager. Enumerate the devices and
     // open the first one, and then start it.
     base::PostTaskAndReplyWithResult(device_loop_, FROM_HERE,
         base::Bind(&VideoCaptureManager::GetAvailableDevicesOnDeviceThread,
                    this, MEDIA_DEVICE_VIDEO_CAPTURE),
         base::Bind(&VideoCaptureManager::OpenAndStartDefaultSession, this,
                    capture_params, client_render_process, client_id,
                    client_handler, done_cb));
     return;
   } else {
     DoStartCaptureForClient(capture_params, client_render_process, client_id,
                             client_handler, done_cb);
   }
 }
 
 void VideoCaptureManager::DoStartCaptureForClient(
     const media::VideoCaptureParams& capture_params,
     base::ProcessHandle client_render_process,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler,
-    base::Callback<void(VideoCaptureController*)> done_cb) {
+    const DoneCB& done_cb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceEntry* entry = GetOrCreateDeviceEntry(capture_params.session_id);
   if (!entry) {
-    done_cb.Run(NULL);
+    done_cb.Run(base::WeakPtr<VideoCaptureController>());
     return;
   }
 
   DCHECK(entry->video_capture_controller);
 
   // First client starts the device.
   if (entry->video_capture_controller->GetClientCount() == 0) {
     DVLOG(1) << "VideoCaptureManager starting device (type = "
              << entry->stream_type << ", id = " << entry->id << ")";
 
     media::VideoCaptureCapability params_as_capability;
     params_as_capability.width = capture_params.width;
     params_as_capability.height = capture_params.height;
     params_as_capability.frame_rate = capture_params.frame_rate;
     params_as_capability.session_id = capture_params.session_id;
     params_as_capability.frame_size_type = capture_params.frame_size_type;
 
     device_loop_->PostTask(FROM_HERE, base::Bind(
         &VideoCaptureManager::DoStartDeviceOnDeviceThread, this,
-        entry, params_as_capability, entry->video_capture_controller));
+        entry, params_as_capability,
+        base::Passed(entry->video_capture_controller->NewDeviceClient())));
   }
   // Run the callback first, as AddClient() may trigger OnFrameInfo().
-  done_cb.Run(entry->video_capture_controller);
+  done_cb.Run(entry->video_capture_controller->GetWeakPtr());
   entry->video_capture_controller->AddClient(client_id,
                                              client_handler,
                                              client_render_process,
                                              capture_params);
 }
 
 void VideoCaptureManager::StopCaptureForClient(
     VideoCaptureController* controller,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler) {
@@ skipping 21 matching lines @@
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&VideoCaptureManager::OnClosed, this,
                    MEDIA_DEVICE_VIDEO_CAPTURE, kStartOpenSessionId));
   }
 }
 
 void VideoCaptureManager::DoStopDeviceOnDeviceThread(DeviceEntry* entry) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StopDeviceTime");
   DCHECK(IsOnDeviceThread());
   if (entry->video_capture_device) {
-    // TODO(nick): Merge Stop() and DeAllocate(). http://crbug.com/285562
-    entry->video_capture_device->Stop();
-    entry->video_capture_device->DeAllocate();
-    entry->video_capture_device.reset();
+    entry->video_capture_device->StopAndDeAllocate();
   }
-}
-
-void VideoCaptureManager::FreeDeviceEntryOnIOThread(
-    scoped_ptr<DeviceEntry> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  entry->video_capture_controller = NULL;
-  entry.reset();
+  entry->video_capture_device.reset();
 }
 
 void VideoCaptureManager::OnOpened(MediaStreamType stream_type,
                                    int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   listener_->Opened(stream_type, capture_session_id);
@@ skipping 97 matching lines @@
     }
   }
   return NULL;
 }
 
 void VideoCaptureManager::OpenAndStartDefaultSession(
     const media::VideoCaptureParams& capture_params,
     base::ProcessHandle client_render_process,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler,
-    base::Callback<void(VideoCaptureController*)> done_cb,
+    const DoneCB& done_cb,
     const media::VideoCaptureDevice::Names& device_names) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // |device_names| is a value returned by GetAvailableDevicesOnDeviceThread().
   // We'll mimic an Open() operation on the first element in that list.
   DCHECK(capture_params.session_id == kStartOpenSessionId);
   if (device_names.empty() ||
       sessions_.count(capture_params.session_id) != 0) {
-    done_cb.Run(NULL);
+    done_cb.Run(base::WeakPtr<VideoCaptureController>());
     return;
   }
 
   // Open the device by creating a |sessions_| entry.
   sessions_[capture_params.session_id] =
       MediaStreamDevice(MEDIA_DEVICE_VIDEO_CAPTURE,
                         device_names.front().id(),
                         device_names.front().GetNameAndModel());
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureManager::OnOpened, this,
                  MEDIA_DEVICE_VIDEO_CAPTURE, kStartOpenSessionId));
 
   DoStartCaptureForClient(capture_params, client_render_process, client_id,
                           client_handler, done_cb);
 }
 
 void VideoCaptureManager::DestroyDeviceEntryIfNoClients(DeviceEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Removal of the last client stops the device.
   if (entry->video_capture_controller->GetClientCount() == 0) {
     DVLOG(1) << "VideoCaptureManager stopping device (type = "
              << entry->stream_type << ", id = " << entry->id << ")";
 
-    // The DeviceEntry is removed from |devices_| immediately, but will be torn
-    // down asynchronously. After this point, subsequent request to open this
-    // same device ID will create a new DeviceEntry, VideoCaptureController,
-    // and VideoCaptureDevice.
+    // The DeviceEntry is removed from |devices_| immediately. The controller is
+    // deleted immediately, and the device is freed asynchronously. After this
+    // point, subsequent requests to open this same device ID will create a new
+    // DeviceEntry, VideoCaptureController, and VideoCaptureDevice.
     devices_.erase(entry);
-    device_loop_->PostTaskAndReply(
+    entry->video_capture_controller.reset();
+    device_loop_->PostTask(
         FROM_HERE,
         base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
-                   base::Unretained(entry)),
-        base::Bind(&VideoCaptureManager::FreeDeviceEntryOnIOThread, this,
-                   base::Passed(make_scoped_ptr(entry).Pass())));
+                   base::Owned(entry)));
   }
 }
 
 VideoCaptureManager::DeviceEntry* VideoCaptureManager::GetOrCreateDeviceEntry(
     int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   std::map<int, MediaStreamDevice>::iterator session_it =
       sessions_.find(capture_session_id);
   if (session_it == sessions_.end()) {
     return NULL;
   }
   const MediaStreamDevice& device_info = session_it->second;
 
   // Check if another session has already opened this device. If so, just
   // use that opened device.
   DeviceEntry* const existing_device =
        GetDeviceEntryForMediaStreamDevice(device_info);
   if (existing_device) {
     DCHECK_EQ(device_info.type, existing_device->stream_type);
     return existing_device;
   }
 
-  scoped_refptr<VideoCaptureController> video_capture_controller =
-      new VideoCaptureController();
+  scoped_ptr<VideoCaptureController> video_capture_controller(
+      new VideoCaptureController());
   DeviceEntry* new_device = new DeviceEntry(device_info.type,
                                             device_info.id,
-                                            video_capture_controller);
+                                            video_capture_controller.Pass());
   devices_.insert(new_device);
   return new_device;
 }
 
 }  // namespace content