Make VideoCaptureController single-threaded and not ref counted.

content/browser/renderer_host/media/video_capture_controller.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_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 75 matching lines @@
   // VideoCaptureController* pointer, its ControllerClient entry lives on until
   // it unregisters itself via RemoveClient(), which may happen asynchronously.
   //
   // TODO(nick): If we changed the semantics of VideoCaptureHost so that
   // OnEnded() events were processed synchronously (with the RemoveClient() done
   // implicitly), we could avoid tracking this state here in the Controller, and
   // simplify the code in both places.
   bool session_closed;
 };
 
+// Receives events from the VideoCaptureDevice and posts them to a
+// VideoCaptureController on the IO thread. An instance of this class may safely
+// outlive its target VideoCaptureController.
+//
+// Methods of this class may be called from any thread, and in practice will
+// often be called on some auxiliary thread depending on the platform and the
+// device type; including, for example, the DirectShow thread on Windows, the
+// v4l2_thread on Linux, and the UI thread for tab capture.
+class VideoCaptureController::VideoCaptureDeviceClient
+    : public media::VideoCaptureDevice::EventHandler {
+ public:
+  explicit VideoCaptureDeviceClient(
+      const base::WeakPtr<VideoCaptureController>& controller);
+  virtual ~VideoCaptureDeviceClient();
+
+  // VideoCaptureDevice::EventHandler implementation.
+  virtual scoped_refptr<media::VideoFrame> ReserveOutputBuffer() OVERRIDE;
+  virtual void OnIncomingCapturedFrame(const uint8* data,
+                                       int length,
+                                       base::Time timestamp,
+                                       int rotation,
+                                       bool flip_vert,
+                                       bool flip_horiz) OVERRIDE;
+  virtual void OnIncomingCapturedVideoFrame(
+      const scoped_refptr<media::VideoFrame>& frame,
+      base::Time timestamp) OVERRIDE;
+  virtual void OnError() OVERRIDE;
+  virtual void OnFrameInfo(
+      const media::VideoCaptureCapability& info) OVERRIDE;
+  virtual void OnFrameInfoChanged(
+      const media::VideoCaptureCapability& info) OVERRIDE;
+
+ private:
+  // The controller to which we post events.
+  const base::WeakPtr<VideoCaptureController> controller_;
+
+  // The pool of shared-memory buffers used for capturing.
+  scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
+
+  // Chopped pixels in width/height in case video capture device has odd
+  // numbers for width/height.
+  int chopped_width_;
+  int chopped_height_;
+
+  // Tracks the current frame format.
+  media::VideoCaptureCapability frame_info_;
+};
+
 VideoCaptureController::VideoCaptureController()
-    : chopped_width_(0),
-      chopped_height_(0),
-      frame_info_available_(false),
-      state_(VIDEO_CAPTURE_STATE_STARTED) {
+    : state_(VIDEO_CAPTURE_STATE_STARTED),

[wjia(left Chromium), 2013/09/18 01:29:02]

|state_| is not really needed any more since there are only 2 states: valid and
error. A boolean is good enough, e.g., has_error_.

+      weak_ptr_factory_(this) {
   memset(&current_params_, 0, sizeof(current_params_));
 }
 
+VideoCaptureController::VideoCaptureDeviceClient::VideoCaptureDeviceClient(
+    const base::WeakPtr<VideoCaptureController>& controller)
+    : controller_(controller),
+      chopped_width_(0),
+      chopped_height_(0) {}
+
+VideoCaptureController::VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {}
+
+base::WeakPtr<VideoCaptureController> VideoCaptureController::GetWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
+scoped_ptr<media::VideoCaptureDevice::EventHandler>
+VideoCaptureController::NewDeviceClient() {
+  scoped_ptr<media::VideoCaptureDevice::EventHandler> result(
+      new VideoCaptureDeviceClient(this->GetWeakPtr()));
+  return result.Pass();
+}
+
 void VideoCaptureController::AddClient(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler,
     base::ProcessHandle render_process,
     const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::AddClient, id " << id.device_id
            << ", (" << params.width
            << ", " << params.height
            << ", " << params.frame_rate
            << ", " << params.session_id
            << ")";
 
   // Signal error in case device is already in error state.
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     event_handler->OnError(id);
     return;
   }
 
   // Do nothing if this client has called AddClient before.
   if (FindClient(id, event_handler, controller_clients_))
     return;
 
   ControllerClient* client = new ControllerClient(id, event_handler,
                                                   render_process, params);
   // If we already have gotten frame_info from the device, repeat it to the new
   // client.
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
-    if (frame_info_available_) {
+    if (frame_info_.IsValid()) {
       SendFrameInfoAndBuffers(client);
     }
     controller_clients_.push_back(client);
     return;
   }
 }
 
 int VideoCaptureController::RemoveClient(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler) {
@@ skipping 15 matching lines @@
   }
   client->buffers.clear();
 
   int session_id = client->parameters.session_id;
   controller_clients_.remove(client);
   delete client;
 
   return session_id;
 }
 
-void VideoCaptureController::StopSession(
-    int session_id) {
+void VideoCaptureController::StopSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::StopSession, id " << session_id;
 
   ControllerClient* client = FindClient(session_id, controller_clients_);
 
   if (client) {
     client->session_closed = true;
     client->event_handler->OnEnded(client->controller_id);
   }
 }
@@ skipping 11 matching lines @@
   if (!client ||
       client->buffers.find(buffer_id) == client->buffers.end()) {
     NOTREACHED();
     return;
   }
 
   client->buffers.erase(buffer_id);
   buffer_pool_->RelinquishConsumerHold(buffer_id, 1);
 }
 
-scoped_refptr<media::VideoFrame> VideoCaptureController::ReserveOutputBuffer() {
-  base::AutoLock lock(buffer_pool_lock_);
-  if (!buffer_pool_.get())
-    return NULL;
+scoped_refptr<media::VideoFrame>
+VideoCaptureController::VideoCaptureDeviceClient::ReserveOutputBuffer() {
   return buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
                                                        frame_info_.height),
                                              0);
 }
 
-// Implements VideoCaptureDevice::EventHandler.
-// OnIncomingCapturedFrame is called the thread running the capture device.
-// I.e.- DirectShow thread on windows and v4l2_thread on Linux.
 #if !defined(OS_IOS) && !defined(OS_ANDROID)
-void VideoCaptureController::OnIncomingCapturedFrame(
+void VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
     bool flip_vert,
     bool flip_horiz) {
   TRACE_EVENT0("video", "VideoCaptureController::OnIncomingCapturedFrame");
 
-  scoped_refptr<media::VideoFrame> dst;
-  {
-    base::AutoLock lock(buffer_pool_lock_);
-    if (!buffer_pool_.get())
-      return;
-    dst = buffer_pool_->ReserveI420VideoFrame(
-        gfx::Size(frame_info_.width, frame_info_.height), rotation);
-  }
+  if (!buffer_pool_.get())
+    return;
+  scoped_refptr<media::VideoFrame> dst = buffer_pool_->ReserveI420VideoFrame(
+      gfx::Size(frame_info_.width, frame_info_.height), rotation);
 
   if (!dst.get())
     return;
 
   uint8* yplane = dst->data(media::VideoFrame::kYPlane);
   uint8* uplane = dst->data(media::VideoFrame::kUPlane);
   uint8* vplane = dst->data(media::VideoFrame::kVPlane);
   int yplane_stride = frame_info_.width;
   int uv_plane_stride = (frame_info_.width + 1) / 2;
   int crop_x = 0;
@@ skipping 88 matching lines @@
         frame_info_.height * (flip_vert ^ flip_horiz ? -1 : 1),
         frame_info_.width,
         frame_info_.height,
         rotation_mode,
         origin_colorspace);
   }
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
-                 this,
+                 controller_,
                  dst,
                  timestamp));
 }
 #else
-void VideoCaptureController::OnIncomingCapturedFrame(
+void VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
     bool flip_vert,
     bool flip_horiz) {
   DCHECK(frame_info_.color == media::PIXEL_FORMAT_I420 ||
          frame_info_.color == media::PIXEL_FORMAT_YV12 ||
          (rotation == 0 && !flip_vert && !flip_horiz));
 
   TRACE_EVENT0("video", "VideoCaptureController::OnIncomingCapturedFrame");
 
-  scoped_refptr<media::VideoFrame> dst;
-  {
-    base::AutoLock lock(buffer_pool_lock_);
-    if (!buffer_pool_.get())
-      return;
-    dst = buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
-                                                        frame_info_.height),
-                                              rotation);
-  }
+  if (!buffer_pool_)
+    return;
+  scoped_refptr<media::VideoFrame> dst =
+      buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
+                                                    frame_info_.height),
+                                          rotation);
 
   if (!dst.get())
     return;
 
   uint8* yplane = dst->data(media::VideoFrame::kYPlane);
   uint8* uplane = dst->data(media::VideoFrame::kUPlane);
   uint8* vplane = dst->data(media::VideoFrame::kVPlane);
 
   // Do color conversion from the camera format to I420.
   switch (frame_info_.color) {
@@ skipping 43 matching lines @@
                                (frame_info_.width + chopped_width_) * 4,
                                frame_info_.width, frame_info_.width / 2);
       break;
     default:
       NOTREACHED();
   }
 
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
-                 this, dst, timestamp));
+                 controller_, dst, timestamp));
 }
 #endif  // #if !defined(OS_IOS) && !defined(OS_ANDROID)
 
-// OnIncomingCapturedVideoFrame is called the thread running the capture device.
-void VideoCaptureController::OnIncomingCapturedVideoFrame(
+void
+VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     base::Time timestamp) {
 
-  scoped_refptr<media::VideoFrame> target;
-  {
-    base::AutoLock lock(buffer_pool_lock_);
+  if (!buffer_pool_)
+    return;
 
-    if (!buffer_pool_.get())
-      return;
+  // If this is a frame that belongs to the buffer pool, we can forward it
+  // directly to the IO thread and be done.
+  if (buffer_pool_->RecognizeReservedBuffer(
+      frame->shared_memory_handle()) >= 0) {
+    BrowserThread::PostTask(BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
+                   controller_, frame, timestamp));
+    return;
+  }
 
-    // If this is a frame that belongs to the buffer pool, we can forward it
-    // directly to the IO thread and be done.
-    if (buffer_pool_->RecognizeReservedBuffer(
-        frame->shared_memory_handle()) >= 0) {
-      BrowserThread::PostTask(BrowserThread::IO,
-          FROM_HERE,
-          base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
-                     this, frame, timestamp));
-      return;
-    }
-    // Otherwise, this is a frame that belongs to the caller, and we must copy
-    // it to a frame from the buffer pool.
-    target = buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
-                                                           frame_info_.height),
-                                                 0);
-  }
+  // Otherwise, this is a frame that belongs to the caller, and we must copy
+  // it to a frame from the buffer pool.
+  scoped_refptr<media::VideoFrame> target =
+      buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
+                                                    frame_info_.height),
+                                          0);
 
   if (!target.get())
     return;
 
   // Validate the inputs.
   if (frame->coded_size() != target->coded_size())
     return;  // Only exact copies are supported.
   if (!(frame->format() == media::VideoFrame::I420 ||
         frame->format() == media::VideoFrame::YV12 ||
         frame->format() == media::VideoFrame::RGB32)) {
@@ skipping 67 matching lines @@
                                frame->stride(kRGBPlane),
                                target->stride(kYPlane),
                                target->stride(kUPlane));
       break;
     }
   }
 
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
-                 this, target, timestamp));
+                 controller_, target, timestamp));
 }
 
-void VideoCaptureController::OnError() {
+void VideoCaptureController::VideoCaptureDeviceClient::OnError() {
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&VideoCaptureController::DoErrorOnIOThread, this));
+      base::Bind(&VideoCaptureController::DoErrorOnIOThread, controller_));
 }
 
-void VideoCaptureController::OnFrameInfo(
+void VideoCaptureController::VideoCaptureDeviceClient::OnFrameInfo(
     const media::VideoCaptureCapability& info) {
-  frame_info_= info;
+  frame_info_ = info;
   // Handle cases when |info| has odd numbers for width/height.
   if (info.width & 1) {
     --frame_info_.width;
     chopped_width_ = 1;
   } else {
     chopped_width_ = 0;
   }
   if (info.height & 1) {
     --frame_info_.height;
     chopped_height_ = 1;
   } else {
     chopped_height_ = 0;
   }
+
+  DCHECK(!buffer_pool_.get());
+
+  // TODO(nick): Give BufferPool the same lifetime as the controller, have it
+  // support frame size changes, and stop checking it for NULL everywhere.
+  // http://crbug.com/266082
+  buffer_pool_ = new VideoCaptureBufferPool(
+      media::VideoFrame::AllocationSize(
+            media::VideoFrame::I420,
+            gfx::Size(frame_info_.width, frame_info_.height)),
+      kNoOfBuffers);
+
+  // Check whether all buffers were created successfully.
+  if (!buffer_pool_->Allocate()) {
+    // Transition to the error state.
+    buffer_pool_ = NULL;
+    OnError();
+    return;
+  }
+
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&VideoCaptureController::DoFrameInfoOnIOThread, this));
+      base::Bind(&VideoCaptureController::DoFrameInfoOnIOThread, controller_,
+                 frame_info_, buffer_pool_));
 }
 
-void VideoCaptureController::OnFrameInfoChanged(
+void VideoCaptureController::VideoCaptureDeviceClient::OnFrameInfoChanged(
     const media::VideoCaptureCapability& info) {
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoFrameInfoChangedOnIOThread,
-                 this, info));
+                 controller_, info));
 }
 
 VideoCaptureController::~VideoCaptureController() {
   buffer_pool_ = NULL;  // Release all buffers.
   STLDeleteContainerPointers(controller_clients_.begin(),
                              controller_clients_.end());
 }
 
 void VideoCaptureController::DoIncomingCapturedFrameOnIOThread(
     const scoped_refptr<media::VideoFrame>& reserved_frame,
     base::Time timestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!buffer_pool_.get())
     return;
 
   int buffer_id = buffer_pool_->RecognizeReservedBuffer(
       reserved_frame->shared_memory_handle());

[wjia(left Chromium), 2013/09/18 01:29:02]

In case number of live clients (i.e., the |count| below) is zero, does it make
sense to reserve a buffer?

   if (buffer_id < 0) {
     NOTREACHED();
     return;
   }
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     for (ControllerClients::iterator client_it = controller_clients_.begin();
          client_it != controller_clients_.end(); ++client_it) {
       if ((*client_it)->session_closed)
         continue;
 
       (*client_it)->event_handler->OnBufferReady((*client_it)->controller_id,
                                                  buffer_id, timestamp);
       (*client_it)->buffers.insert(buffer_id);
       count++;
     }
   }
 
   buffer_pool_->HoldForConsumers(buffer_id, count);
 }
 
-void VideoCaptureController::DoFrameInfoOnIOThread() {
+void VideoCaptureController::DoFrameInfoOnIOThread(
+    const media::VideoCaptureCapability& frame_info,
+    const scoped_refptr<VideoCaptureBufferPool>& buffer_pool) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!buffer_pool_.get()) << "Frame info should happen only once.";
 
   // Allocate memory only when device has been started.

[wjia(left Chromium), 2013/09/18 01:29:02]

This would be changed to "Allocate memory only when device has no error.".

   if (state_ != VIDEO_CAPTURE_STATE_STARTED)
     return;
 
-  scoped_refptr<VideoCaptureBufferPool> buffer_pool =
-      new VideoCaptureBufferPool(
-          media::VideoFrame::AllocationSize(
-              media::VideoFrame::I420,
-              gfx::Size(frame_info_.width, frame_info_.height)),
-          kNoOfBuffers);
-
-  // Check whether all buffers were created successfully.
-  if (!buffer_pool->Allocate()) {
-    DoErrorOnIOThread();
-    return;
-  }
-
-  {
-    base::AutoLock lock(buffer_pool_lock_);
-    buffer_pool_ = buffer_pool;
-  }
-  frame_info_available_ = true;
+  frame_info_ = frame_info;
+  buffer_pool_ = buffer_pool;
 
   for (ControllerClients::iterator client_it = controller_clients_.begin();
        client_it != controller_clients_.end(); ++client_it) {
     if ((*client_it)->session_closed)
         continue;
 
     SendFrameInfoAndBuffers(*client_it);
   }
 }
 
@@ skipping 23 matching lines @@
        client_it != controller_clients_.end(); ++client_it) {
      if ((*client_it)->session_closed)
         continue;
 
     (*client_it)->event_handler->OnError((*client_it)->controller_id);
   }
 }
 
 void VideoCaptureController::SendFrameInfoAndBuffers(ControllerClient* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(frame_info_available_);
+  DCHECK(frame_info_.IsValid());
   client->event_handler->OnFrameInfo(client->controller_id,
                                      frame_info_);
   for (int buffer_id = 0; buffer_id < buffer_pool_->count(); ++buffer_id) {
     base::SharedMemoryHandle remote_handle =
         buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle);
 
     client->event_handler->OnBufferCreated(client->controller_id,
                                            remote_handle,
                                            buffer_pool_->GetMemorySize(),
                                            buffer_id);
@@ skipping 27 matching lines @@
   }
   return NULL;
 }
 
 int VideoCaptureController::GetClientCount() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return controller_clients_.size();
 }
 
 }  // namespace content