From Video Capture, abolish OnFrameInfo and enable resolution changes

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 59 matching lines @@
   ~ControllerClient() {}
 
   // ID used for identifying this object.
   VideoCaptureControllerID controller_id;
   VideoCaptureControllerEventHandler* event_handler;
 
   // Handle to the render process that will receive the capture buffers.
   base::ProcessHandle render_process_handle;
   media::VideoCaptureParams parameters;
 
-  // Buffers used by this client.
-  std::set<int> buffers;
+  // Buffers that are currently known to this client.
+  std::set<int> known_buffers;
+
+  // Buffers currently held by this client.
+  std::set<int> active_buffers;
 
   // State of capture session, controlled by VideoCaptureManager directly. This
   // transitions to true as soon as StopSession() occurs, at which point the
   // client is sent an OnEnded() event. However, because the client retains a
   // 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::Client {
  public:
   explicit VideoCaptureDeviceClient(
-      const base::WeakPtr<VideoCaptureController>& controller);
+      const base::WeakPtr<VideoCaptureController>& controller,
+      const scoped_refptr<VideoCaptureBufferPool>& buffer_pool);
   virtual ~VideoCaptureDeviceClient();
 
   // VideoCaptureDevice::Client implementation.
-  virtual scoped_refptr<media::VideoFrame> ReserveOutputBuffer() OVERRIDE;
+  virtual scoped_refptr<media::VideoFrame> ReserveOutputBuffer(
+      const gfx::Size& size) 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:
+  void HandleDroppedBufferId(int buffer_id_to_drop);
+
   // 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_;
+  const 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_;
 
   // For NV21 we have to do color conversion into the intermediate buffer and
   // from there the rotations. This variable won't be needed after
   // http://crbug.com/292400
 #if defined(OS_IOS) || defined(OS_ANDROID)
   scoped_ptr<uint8[]> i420_intermediate_buffer_;
 #endif  // #if defined(OS_IOS) || defined(OS_ANDROID)
 };
 
 VideoCaptureController::VideoCaptureController()
-    : state_(VIDEO_CAPTURE_STATE_STARTED),
+    : buffer_pool_(new VideoCaptureBufferPool(kNoOfBuffers)),
+      state_(VIDEO_CAPTURE_STATE_STARTED),
       weak_ptr_factory_(this) {
-  memset(&current_params_, 0, sizeof(current_params_));
 }
 
 VideoCaptureController::VideoCaptureDeviceClient::VideoCaptureDeviceClient(
-    const base::WeakPtr<VideoCaptureController>& controller)
+    const base::WeakPtr<VideoCaptureController>& controller,
+    const scoped_refptr<VideoCaptureBufferPool>& buffer_pool)
     : controller_(controller),
+      buffer_pool_(buffer_pool),
       chopped_width_(0),
       chopped_height_(0) {}
 
 VideoCaptureController::VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {}
 
 base::WeakPtr<VideoCaptureController> VideoCaptureController::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 scoped_ptr<media::VideoCaptureDevice::Client>
 VideoCaptureController::NewDeviceClient() {
   scoped_ptr<media::VideoCaptureDevice::Client> result(
-      new VideoCaptureDeviceClient(this->GetWeakPtr()));
+      new VideoCaptureDeviceClient(this->GetWeakPtr(), buffer_pool_));
   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
@@ skipping 11 matching lines @@
 
   // 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_.IsValid()) {
-      SendFrameInfoAndBuffers(client);
-    }
     controller_clients_.push_back(client);
     return;
   }
 }
 
 int VideoCaptureController::RemoveClient(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::RemoveClient, id " << id.device_id;
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
   if (!client)
     return kInvalidMediaCaptureSessionId;
 
   // Take back all buffers held by the |client|.
-  if (buffer_pool_.get()) {
-    for (std::set<int>::iterator buffer_it = client->buffers.begin();
-         buffer_it != client->buffers.end();
-         ++buffer_it) {
-      int buffer_id = *buffer_it;
-      buffer_pool_->RelinquishConsumerHold(buffer_id, 1);
-    }
+  for (std::set<int>::iterator buffer_it = client->active_buffers.begin();
+       buffer_it != client->active_buffers.end();
+       ++buffer_it) {
+    int buffer_id = *buffer_it;
+    buffer_pool_->RelinquishConsumerHold(buffer_id, 1);
   }
-  client->buffers.clear();
+  client->active_buffers.clear();
 
   int session_id = client->parameters.session_id;
   controller_clients_.remove(client);
   delete client;
 
   return session_id;
 }
 
 void VideoCaptureController::StopSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 11 matching lines @@
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler,
     int buffer_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
 
   // If this buffer is not held by this client, or this client doesn't exist
   // in controller, do nothing.
   if (!client ||
-      client->buffers.find(buffer_id) == client->buffers.end()) {
+      client->active_buffers.find(buffer_id) == client->active_buffers.end()) {
     NOTREACHED();
     return;
   }
 
-  client->buffers.erase(buffer_id);
+  client->active_buffers.erase(buffer_id);
   buffer_pool_->RelinquishConsumerHold(buffer_id, 1);
 }
 
 scoped_refptr<media::VideoFrame>
-VideoCaptureController::VideoCaptureDeviceClient::ReserveOutputBuffer() {
-  return buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
-                                                       frame_info_.height),
-                                             0);
+VideoCaptureController::VideoCaptureDeviceClient::ReserveOutputBuffer(
+    const gfx::Size& size) {
+  int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;
+  scoped_refptr<media::VideoFrame> frame =
+      buffer_pool_->ReserveI420VideoFrame(size, 0, &buffer_id_to_drop);
+  HandleDroppedBufferId(buffer_id_to_drop);
+  return frame;
 }
 
 #if !defined(OS_IOS) && !defined(OS_ANDROID)
 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");
 
-  if (!buffer_pool_.get())
+  if (!frame_info_.IsValid())
     return;
+
+  int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;
   scoped_refptr<media::VideoFrame> dst = buffer_pool_->ReserveI420VideoFrame(
-      gfx::Size(frame_info_.width, frame_info_.height), rotation);
+      gfx::Size(frame_info_.width, frame_info_.height), rotation,
+      &buffer_id_to_drop);
+  HandleDroppedBufferId(buffer_id_to_drop);
 
   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 90 matching lines @@
         frame_info_.height,
         rotation_mode,
         origin_colorspace);
   }
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
                  controller_,
                  dst,
+                 frame_info_.frame_rate,
                  timestamp));
 }
 #else
 void VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
     bool flip_vert,
     bool flip_horiz) {
+
+  if (!frame_info_.IsValid())
+    return;
+
   DCHECK(frame_info_.color == media::PIXEL_FORMAT_I420 ||
          frame_info_.color == media::PIXEL_FORMAT_YV12 ||
          frame_info_.color == media::PIXEL_FORMAT_NV21 ||
          (rotation == 0 && !flip_vert && !flip_horiz));
 
   TRACE_EVENT0("video", "VideoCaptureController::OnIncomingCapturedFrame");
 
-  if (!buffer_pool_)
-    return;
+  int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;
   scoped_refptr<media::VideoFrame> dst =
       buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
                                                     frame_info_.height),
-                                          rotation);
-
+                                          rotation,
+                                          &buffer_id_to_drop);
+  HandleDroppedBufferId(buffer_id_to_drop);
   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) {
     case media::PIXEL_FORMAT_UNKNOWN:  // Color format not set.
@@ skipping 52 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,
-                 controller_, dst, timestamp));
+                 controller_, dst, frame_info_.frame_rate, timestamp));
 }
 #endif  // #if !defined(OS_IOS) && !defined(OS_ANDROID)
 
 void
 VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     base::Time timestamp) {
-  if (!buffer_pool_)
-    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));
+                   controller_, frame, frame_info_.frame_rate, timestamp));
     return;
   }
 
-  // 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)) {
-    NOTREACHED() << "Unsupported format passed to OnIncomingCapturedVideoFrame";
-    return;
-  }
-
-  const int kYPlane = media::VideoFrame::kYPlane;
-  const int kUPlane = media::VideoFrame::kUPlane;
-  const int kVPlane = media::VideoFrame::kVPlane;
-  const int kAPlane = media::VideoFrame::kAPlane;
-  const int kRGBPlane = media::VideoFrame::kRGBPlane;
-
-  // Do color conversion from the camera format to I420.
-  switch (frame->format()) {
-#if defined(GOOGLE_TV)
-    case media::VideoFrame::HOLE:
-      // Fall-through to NOTREACHED() block.
-#endif
-    case media::VideoFrame::INVALID:
-    case media::VideoFrame::YV16:
-    case media::VideoFrame::EMPTY:
-    case media::VideoFrame::NATIVE_TEXTURE: {
-      NOTREACHED();
-      break;
-    }
-    case media::VideoFrame::I420:
-    case media::VideoFrame::YV12: {
-      DCHECK(!chopped_width_ && !chopped_height_);
-      media::CopyYPlane(frame->data(kYPlane),
-                        frame->stride(kYPlane),
-                        frame->rows(kYPlane),
-                        target.get());
-      media::CopyUPlane(frame->data(kUPlane),
-                        frame->stride(kUPlane),
-                        frame->rows(kUPlane),
-                        target.get());
-      media::CopyVPlane(frame->data(kVPlane),
-                        frame->stride(kVPlane),
-                        frame->rows(kVPlane),
-                        target.get());
-      break;
-    }
-    case media::VideoFrame::YV12A: {
-      DCHECK(!chopped_width_ && !chopped_height_);
-      media::CopyYPlane(frame->data(kYPlane),
-                        frame->stride(kYPlane),
-                        frame->rows(kYPlane),
-                        target.get());
-      media::CopyUPlane(frame->data(kUPlane),
-                        frame->stride(kUPlane),
-                        frame->rows(kUPlane),
-                        target.get());
-      media::CopyVPlane(frame->data(kVPlane),
-                        frame->stride(kVPlane),
-                        frame->rows(kVPlane),
-                        target.get());
-      media::CopyAPlane(frame->data(kAPlane),
-                        frame->stride(kAPlane),
-                        frame->rows(kAPlane),
-                        target.get());
-      break;
-    }
-    case media::VideoFrame::RGB32: {
-      media::ConvertRGB32ToYUV(frame->data(kRGBPlane),
-                               target->data(kYPlane),
-                               target->data(kUPlane),
-                               target->data(kVPlane),
-                               target->coded_size().width(),
-                               target->coded_size().height(),
-                               frame->stride(kRGBPlane),
-                               target->stride(kYPlane),
-                               target->stride(kUPlane));
-      break;
-    }
-  }
-
-  BrowserThread::PostTask(BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
-                 controller_, target, timestamp));
+  NOTREACHED() << "Frames should always belong to the buffer pool.";
 }
 
 void VideoCaptureController::VideoCaptureDeviceClient::OnError() {
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoErrorOnIOThread, controller_));
 }
 
 void VideoCaptureController::VideoCaptureDeviceClient::OnFrameInfo(
     const media::VideoCaptureCapability& 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;
   }
 #if defined(OS_IOS) || defined(OS_ANDROID)
-  if (frame_info_.color == media::PIXEL_FORMAT_NV21 &&
-      !i420_intermediate_buffer_) {
+  if (frame_info_.color == media::PIXEL_FORMAT_NV21) {
     i420_intermediate_buffer_.reset(
         new uint8[frame_info_.width * frame_info_.height * 12 / 8]);
   }
 #endif  // #if defined(OS_IOS) || defined(OS_ANDROID)
-
-  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, controller_,
-                 frame_info_, buffer_pool_));
 }
 
 void VideoCaptureController::VideoCaptureDeviceClient::OnFrameInfoChanged(
     const media::VideoCaptureCapability& info) {
-  BrowserThread::PostTask(BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&VideoCaptureController::DoFrameInfoChangedOnIOThread,
-                 controller_, info));
+  OnFrameInfo(info);
+}
+
+void VideoCaptureController::VideoCaptureDeviceClient::HandleDroppedBufferId(
+    int buffer_id_to_drop) {
+  if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId) {
+    BrowserThread::PostTask(BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&VideoCaptureController::DoBufferDestroyedOnIOThread,
+                   controller_, buffer_id_to_drop));
+  }
 }
 
 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,
+    int frame_rate,
     base::Time timestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (!buffer_pool_.get())
-    return;
-
   int buffer_id = buffer_pool_->RecognizeReservedBuffer(
       reserved_frame->shared_memory_handle());
   if (buffer_id < 0) {
     NOTREACHED();
     return;
   }
 
+  media::VideoCaptureFormat frame_format(
+      reserved_frame->coded_size().width(),
+      reserved_frame->coded_size().height(),
+      frame_rate,
+      media::VariableResolutionVideoCaptureDevice);
+
   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)
+      ControllerClient* client = *client_it;
+      if (client->session_closed)
         continue;
 
-      (*client_it)->event_handler->OnBufferReady((*client_it)->controller_id,
-                                                 buffer_id, timestamp);
-      (*client_it)->buffers.insert(buffer_id);
+      if (!client->known_buffers.count(buffer_id)) {
+        // On the first use of a buffer on a client, share the memory handle.
+        size_t memory_size = 0;
+        base::SharedMemoryHandle remote_handle = buffer_pool_->ShareToProcess(
+            buffer_id, client->render_process_handle, &memory_size);
+        client->event_handler->OnBufferCreated(client->controller_id,
+                                               remote_handle,
+                                               memory_size,
+                                               buffer_id);
+        client->known_buffers.insert(buffer_id);
+      }
+
+      client->event_handler->OnBufferReady(client->controller_id,
+                                           buffer_id, timestamp,
+                                           frame_format);
+      client->active_buffers.insert(buffer_id);
       count++;
     }
   }
 
   buffer_pool_->HoldForConsumers(buffer_id, count);
 }
 
-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.
-  if (state_ != VIDEO_CAPTURE_STATE_STARTED)
-    return;
-
-  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);
-  }
-}
-
-void VideoCaptureController::DoFrameInfoChangedOnIOThread(
-    const media::VideoCaptureCapability& info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  // TODO(mcasas): Here we should reallocate the VideoCaptureBufferPool, if
-  // needed, to support the new video capture format. See crbug.com/266082.
-  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->OnFrameInfoChanged(
-        (*client_it)->controller_id,
-        info.width,
-        info.height,
-        info.frame_rate);
-  }
-}
-
 void VideoCaptureController::DoErrorOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   state_ = VIDEO_CAPTURE_STATE_ERROR;
-  ControllerClients::iterator client_it;
-  for (client_it = controller_clients_.begin();
+
+  for (ControllerClients::iterator client_it = controller_clients_.begin();
        client_it != controller_clients_.end(); ++client_it) {
-     if ((*client_it)->session_closed)
-        continue;
+    ControllerClient* client = *client_it;
+    if (client->session_closed)
+       continue;
 
-    (*client_it)->event_handler->OnError((*client_it)->controller_id);
+    client->event_handler->OnError(client->controller_id);
   }
 }
 
-void VideoCaptureController::SendFrameInfoAndBuffers(ControllerClient* client) {
+void VideoCaptureController::DoBufferDestroyedOnIOThread(
+    int buffer_id_to_drop) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  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);
+  for (ControllerClients::iterator client_it = controller_clients_.begin();
+       client_it != controller_clients_.end(); ++client_it) {
+    ControllerClient* client = *client_it;
+    if (client->session_closed)
+      continue;
+
+    if (client->known_buffers.erase(buffer_id_to_drop)) {
+      client->event_handler->OnBufferDestroyed(client->controller_id,
+                                               buffer_id_to_drop);
+    }
   }
 }
 
 VideoCaptureController::ControllerClient*
 VideoCaptureController::FindClient(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
   for (ControllerClients::const_iterator client_it = clients.begin();
        client_it != clients.end(); ++client_it) {
@@ skipping 17 matching lines @@
   }
   return NULL;
 }
 
 int VideoCaptureController::GetClientCount() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return controller_clients_.size();
 }
 
 }  // namespace content