Make VideoCaptureController single-threaded and not ref counted.

content/browser/renderer_host/media/video_capture_host.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_host.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/video_capture_messages.h"
 
 namespace content {
 
 struct VideoCaptureHost::Entry {

[Ami GONE FROM CHROMIUM, 2013/09/13 21:17:59]

What's the point of this struct now? 
(feels like the answer is either "oops, no longer necessary" or "shhh!  I'm
doing something icky with managing weakptrs across threads!  Don't look too
closely!"; I'm hoping the answer is the former :))

[ncarter (slow), 2013/09/14 00:07:24]

What was the point of it before?

The point of this struct is to give you and me jobs. As to the point of that,
it's a harder question to answer.

Nuked it from space.

-  Entry(VideoCaptureController* controller)
-      : controller(controller) {}
-
-  ~Entry() {}
-
-  scoped_refptr<VideoCaptureController> controller;
+  base::WeakPtr<VideoCaptureController> controller;
 };
 
 VideoCaptureHost::VideoCaptureHost(MediaStreamManager* media_stream_manager)
     : media_stream_manager_(media_stream_manager) {
 }
 
 VideoCaptureHost::~VideoCaptureHost() {}
 
 void VideoCaptureHost::OnChannelClosing() {
   BrowserMessageFilter::OnChannelClosing();
@@ skipping 181 matching lines @@
   DVLOG(1) << "VideoCaptureHost::OnStartCapture, device_id " << device_id
            << ", (" << params.width << ", " << params.height << ", "
            << params.frame_rate << ", " << params.session_id
            << ", variable resolution device:"
            << ((params.frame_size_type ==
                media::VariableResolutionVideoCaptureDevice) ? "yes" : "no")
             << ")";
   VideoCaptureControllerID controller_id(device_id);
   DCHECK(entries_.find(controller_id) == entries_.end());
 
-  entries_[controller_id] = new Entry(NULL);
+  entries_[controller_id] = new Entry();
   media_stream_manager_->video_capture_manager()->StartCaptureForClient(
       params, PeerHandle(), controller_id, this, base::Bind(
           &VideoCaptureHost::OnControllerAdded, this, device_id, params));
 }
 
 void VideoCaptureHost::OnControllerAdded(
     int device_id, const media::VideoCaptureParams& params,
-    VideoCaptureController* controller) {
+    base::WeakPtr<VideoCaptureController> controller) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureHost::DoControllerAddedOnIOThread,
-                 this, device_id, params, make_scoped_refptr(controller)));
+                 this, device_id, params, controller));
 }
 
 void VideoCaptureHost::DoControllerAddedOnIOThread(
     int device_id, const media::VideoCaptureParams params,
-    VideoCaptureController* controller) {
+    base::WeakPtr<VideoCaptureController> controller) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   VideoCaptureControllerID controller_id(device_id);
   EntryMap::iterator it = entries_.find(controller_id);
   if (it == entries_.end()) {
     if (controller) {
       media_stream_manager_->video_capture_manager()->StopCaptureForClient(
-          controller, controller_id, this);
+          controller.get(), controller_id, this);
     }
     return;
   }
 
-  if (controller == NULL) {
+  if (!controller) {
     Send(new VideoCaptureMsg_StateChanged(device_id,
                                           VIDEO_CAPTURE_STATE_ERROR));
     delete it->second;
     entries_.erase(controller_id);
     return;
   }
 
   it->second->controller = controller;
 }
 
@@ skipping 14 matching lines @@
   // Not used.
   Send(new VideoCaptureMsg_StateChanged(device_id, VIDEO_CAPTURE_STATE_ERROR));
 }
 
 void VideoCaptureHost::OnReceiveEmptyBuffer(int device_id, int buffer_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   VideoCaptureControllerID controller_id(device_id);
   EntryMap::iterator it = entries_.find(controller_id);
   if (it != entries_.end()) {
-    scoped_refptr<VideoCaptureController> controller = it->second->controller;
-    if (controller.get())
+    base::WeakPtr<VideoCaptureController> controller = it->second->controller;
+    if (controller)
       controller->ReturnBuffer(controller_id, this, buffer_id);
   }
 }
 
 void VideoCaptureHost::DeleteVideoCaptureControllerOnIOThread(
     const VideoCaptureControllerID& controller_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   EntryMap::iterator it = entries_.find(controller_id);
   if (it == entries_.end())
     return;
 
-  VideoCaptureController* controller = it->second->controller.get();
-  if (controller) {
+  if (it->second->controller) {
     media_stream_manager_->video_capture_manager()->StopCaptureForClient(
-        controller, controller_id, this);
+        it->second->controller.get(), controller_id, this);
   }
   delete it->second;
   entries_.erase(controller_id);
 }
 
 }  // namespace content