enable video capture to support sharing across multiple renderer processes

media/video/capture/linux/video_capture_device_linux.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 "media/video/capture/linux/video_capture_device_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <sys/ioctl.h>
@@ skipping 122 matching lines @@
   }
 }
 
 void VideoCaptureDeviceLinux::Allocate(int width,
                                        int height,
                                        int frame_rate,
                                        EventHandler* observer) {
   if (v4l2_thread_.IsRunning()) {
     return;  // Wrong state.
   }
   v4l2_thread_.Start();

[perkj_chrome, 2011/10/27 07:27:32]

This is what make manager->Start synchronouse.

   v4l2_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureDeviceLinux::OnAllocate, base::Unretained(this),
                  width, height, frame_rate, observer));
 }
 
 void VideoCaptureDeviceLinux::Start() {
   if (!v4l2_thread_.IsRunning()) {
     return;  // Wrong state.
   }
@@ skipping 12 matching lines @@
 }
 
 void VideoCaptureDeviceLinux::DeAllocate() {
   if (!v4l2_thread_.IsRunning()) {
     return;  // Wrong state.
   }
   v4l2_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureDeviceLinux::OnDeAllocate,
                  base::Unretained(this)));
   v4l2_thread_.Stop();

[perkj_chrome, 2011/10/27 07:27:32]

manager->Stop syncronouse.

 
   // Make sure no buffers are still allocated.
   // This can happen (theoretically) if an error occurs when trying to stop
   // the camera.
   DeAllocateVideoBuffers();
 }
 
 const VideoCaptureDevice::Name& VideoCaptureDeviceLinux::device_name() {
   return device_name_;
 }
 
 void VideoCaptureDeviceLinux::OnAllocate(int width,
                                          int height,
                                          int frame_rate,
                                          EventHandler* observer) {
   DCHECK_EQ(v4l2_thread_.message_loop(), MessageLoop::current());
 
   observer_ = observer;
+  observer_->OnDeviceState(true);
 
   if ((device_fd_ = open(device_name_.unique_id.c_str(), O_RDONLY)) < 0) {
     SetErrorState("Failed to open V4L2 device driver.");
     return;
   }
 
   // Test if this is a V4L2 device.
   v4l2_capability cap;
   if (!((ioctl(device_fd_, VIDIOC_QUERYCAP, &cap) == 0) &&
       (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))) {
@@ skipping 230 matching lines @@
   r_buffer.memory = V4L2_MEMORY_MMAP;
   r_buffer.count = 0;
 
   if (ioctl(device_fd_, VIDIOC_REQBUFS, &r_buffer) < 0) {
     SetErrorState("Failed to reset buf.");
   }
 
   delete [] buffer_pool_;
   buffer_pool_ = NULL;
   buffer_pool_size_ = 0;
+  observer_->OnDeviceState(false);
 }
 
 void VideoCaptureDeviceLinux::SetErrorState(const std::string& reason) {
   DLOG(ERROR) << reason;
   state_ = kError;
   observer_->OnError();
 }
 
 }  // namespace media