Moved ownership of camera thread to user image screen

chrome/browser/chromeos/login/camera.cc

 // Copyright (c) 2010 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 "chrome/browser/chromeos/login/camera.h"
 
 #include <stdlib.h>
 #include <fcntl.h>  // low-level i/o
 #include <unistd.h>
 #include <errno.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/mman.h>
 #include <sys/ioctl.h>
 #include <asm/types.h>  // for videodev2.h
 #include <linux/videodev2.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/thread.h"
 #include "base/time.h"
 #include "chrome/browser/browser_thread.h"
 #include "gfx/size.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 
 namespace chromeos {
 
 namespace {
@@ skipping 71 matching lines @@
     if (sizes[i].GetArea() > max_area) {
       max_size_index = i;
       max_area = sizes[i].GetArea();
     }
   }
   return sizes[max_size_index];
 }
 
 // Default camera device name.
 const char kDeviceName[] = "/dev/video0";
-// Name for camera thread.
-const char kCameraThreadName[] = "Chrome_CameraThread";
 // Default width of each frame received from the camera.
 const int kFrameWidth = 640;
 // Default height of each frame received from the camera.
 const int kFrameHeight = 480;
 // Number of buffers to request from the device.
 const int kRequestBuffersCount = 4;
 // Timeout for select() call in microseconds.
 const long kSelectTimeout = 1 * base::Time::kMicrosecondsPerSecond;
 
 }  // namespace
 
-// static
-Lock Camera::image_lock_;
-
-// static
-Lock Camera::thread_lock_;
-
 ///////////////////////////////////////////////////////////////////////////////
 // Camera, public members:
 
-Camera::Camera(Delegate* delegate, bool mirrored)
+Camera::Camera(Delegate* delegate, base::Thread* thread, bool mirrored)
     : delegate_(delegate),
-      camera_thread_(kCameraThreadName),
+      thread_(thread),
       device_name_(kDeviceName),
       device_descriptor_(-1),
       is_capturing_(false),
       desired_width_(kFrameWidth),
       desired_height_(kFrameHeight),
       frame_width_(kFrameWidth),
       frame_height_(kFrameHeight),
       mirrored_(mirrored) {
 }
 
 Camera::~Camera() {
   DCHECK_EQ(-1, device_descriptor_) << "Don't forget to uninitialize camera.";
 }
 
-// If this method is called there's no need to call PostCameraThreadAck().
 void Camera::ReportFailure() {
   DCHECK(IsOnCameraThread());
   if (device_descriptor_ == -1) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableMethod(this,
                           &Camera::OnInitializeFailure));
   } else if (!is_capturing_) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableMethod(this,
                           &Camera::OnStartCapturingFailure));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableMethod(this,
                           &Camera::OnCaptureFailure));
   }
 }
 
 void Camera::Initialize(int desired_width, int desired_height) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PostCameraTask(
+      FROM_HERE,
       NewRunnableMethod(this,
                         &Camera::DoInitialize,
                         desired_width,
                         desired_height));
 }
 
 void Camera::DoInitialize(int desired_width, int desired_height) {
   DCHECK(IsOnCameraThread());
-  DCHECK(delegate_);
 
   if (device_descriptor_ != -1) {
     LOG(WARNING) << "Camera is initialized already.";
-    PostCameraThreadAck();
     return;
   }
 
   int fd = OpenDevice(device_name_.c_str());
   if (fd == -1) {
     ReportFailure();
     return;
   }
 
   v4l2_capability cap;
@@ skipping 35 matching lines @@
   if (!InitializeReadingMode(fd)) {
     ReportFailure();
     return;
   }
 
   device_descriptor_ = fd;
   frame_width_ = frame_size.width();
   frame_height_ = frame_size.height();
   desired_width_ = desired_width;
   desired_height_ = desired_height;
-  // No need to call PostCameraThreadAck() back as this method
-  // is being posted instead.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       NewRunnableMethod(this, &Camera::OnInitializeSuccess));
 }
 
-void Camera::CameraThreadAck() {
-}
-
-void Camera::PostCameraThreadAck() {
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      NewRunnableMethod(this, &Camera::CameraThreadAck));
-}
-
 void Camera::Uninitialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  PostCameraTask(NewRunnableMethod(this, &Camera::DoUninitialize));
+  PostCameraTask(FROM_HERE, NewRunnableMethod(this, &Camera::DoUninitialize));
 }
 
 void Camera::DoUninitialize() {
   DCHECK(IsOnCameraThread());
   if (device_descriptor_ == -1) {
     LOG(WARNING) << "Calling uninitialize for uninitialized camera.";
-    PostCameraThreadAck();
     return;
   }
   DoStopCapturing();
   UnmapVideoBuffers();
   if (close(device_descriptor_) == -1)
     log_errno("Closing the device failed.");
   device_descriptor_ = -1;
-  // Maintain a reference so that camera object isn't deleted on wrong thread.
-  PostCameraThreadAck();
 }
 
 void Camera::StartCapturing() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  PostCameraTask(NewRunnableMethod(this, &Camera::DoStartCapturing));
+  PostCameraTask(FROM_HERE,
+                 NewRunnableMethod(this, &Camera::DoStartCapturing));
 }
 
 void Camera::DoStartCapturing() {
   DCHECK(IsOnCameraThread());
   if (is_capturing_) {
     LOG(WARNING) << "Capturing is already started.";
-    PostCameraThreadAck();
     return;
   }
 
   for (size_t i = 0; i < buffers_.size(); ++i) {
     v4l2_buffer buffer = {};
     buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     buffer.memory = V4L2_MEMORY_MMAP;
     buffer.index = i;
     if (xioctl(device_descriptor_, VIDIOC_QBUF, &buffer) == -1) {
       log_errno("VIDIOC_QBUF failed.");
       ReportFailure();
       return;
     }
   }
   v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   if (xioctl(device_descriptor_, VIDIOC_STREAMON, &type) == -1) {
     log_errno("VIDIOC_STREAMON failed.");
     ReportFailure();
     return;
   }
   // No need to post DidProcessCameraThreadMethod() as this method is
   // being posted instead.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       NewRunnableMethod(this,
                         &Camera::OnStartCapturingSuccess));
   is_capturing_ = true;
-  PostCameraTask(NewRunnableMethod(this, &Camera::OnCapture));
+  PostCameraTask(FROM_HERE,
+                 NewRunnableMethod(this, &Camera::OnCapture));
 }
 
 void Camera::StopCapturing() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  PostCameraTask(NewRunnableMethod(this, &Camera::DoStopCapturing));
+  PostCameraTask(FROM_HERE,
+                 NewRunnableMethod(this, &Camera::DoStopCapturing));
 }
 
 void Camera::DoStopCapturing() {
   DCHECK(IsOnCameraThread());
   if (!is_capturing_) {
-    PostCameraThreadAck();
     LOG(WARNING) << "Calling StopCapturing when capturing is not started.";
     return;
   }
   // OnCapture must exit if this flag is not set.
   is_capturing_ = false;
   v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   if (xioctl(device_descriptor_, VIDIOC_STREAMOFF, &type) == -1)
     log_errno("VIDIOC_STREAMOFF failed.");
-  // Maintain a reference so that camera object isn't deleted on wrong thread.
-  PostCameraThreadAck();
 }
 
 void Camera::GetFrame(SkBitmap* frame) {
   AutoLock lock(image_lock_);
   frame->swap(frame_image_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Camera, private members:
 
@@ skipping 64 matching lines @@
 void Camera::UnmapVideoBuffers() {
   DCHECK(IsOnCameraThread());
   for (size_t i = 0; i < buffers_.size(); ++i) {
     if (munmap(buffers_[i].start, buffers_[i].length) == -1)
       log_errno("munmap failed.");
   }
 }
 
 void Camera::OnCapture() {
   DCHECK(IsOnCameraThread());
-  if (!is_capturing_) {
-    // Maintain a reference so that camera object isn't deleted on wrong thread.
-    PostCameraThreadAck();
+  if (!is_capturing_)
     return;
-  }
 
   do {
     fd_set fds;
     FD_ZERO(&fds);
     FD_SET(device_descriptor_, &fds);
 
     timeval tv = {};
     tv.tv_sec = kSelectTimeout / base::Time::kMicrosecondsPerSecond;
     tv.tv_usec = kSelectTimeout % base::Time::kMicrosecondsPerSecond;
 
     int result = select(device_descriptor_ + 1, &fds, NULL, NULL, &tv);
     if (result == -1) {
       if (errno == EINTR)
         continue;
       log_errno("select() failed.");
       ReportFailure();
       break;
     }
     if (result == 0) {
       LOG(ERROR) << "select() timeout.";
       ReportFailure();
       break;
     }
     // EAGAIN - continue select loop.
   } while (!ReadFrame());
 
-  PostCameraTask(NewRunnableMethod(this, &Camera::OnCapture));
+  PostCameraTask(FROM_HERE,
+                 NewRunnableMethod(this, &Camera::OnCapture));
 }
 
 bool Camera::ReadFrame() {
   DCHECK(IsOnCameraThread());
   v4l2_buffer buffer = {};
   buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   buffer.memory = V4L2_MEMORY_MMAP;
   if (xioctl(device_descriptor_, VIDIOC_DQBUF, &buffer) == -1) {
     // Return false only in this case to try again.
     if (errno == EAGAIN)
@@ skipping 119 matching lines @@
 }
 
 void Camera::OnCaptureFailure() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (delegate_)
     delegate_->OnCaptureFailure();
 }
 
 bool Camera::IsOnCameraThread() const {
   AutoLock lock(thread_lock_);
-  return MessageLoop::current() == camera_thread_.message_loop();
+  return thread_ && MessageLoop::current() == thread_->message_loop();
 }
 
-void Camera::PostCameraTask(Task* task) {
+void Camera::PostCameraTask(const tracked_objects::Location& from_here,
+                            Task* task) {
   AutoLock lock(thread_lock_);
-  if (!camera_thread_.IsRunning())
-    camera_thread_.Start();
-  camera_thread_.message_loop()->PostTask(FROM_HERE, task);
+  if (!thread_)
+    return;
+  DCHECK(thread_->IsRunning());
+  thread_->message_loop()->PostTask(from_here, task);
 }
 
 }  // namespace chromeos