Moved ownership of camera thread to user image screen

chrome/browser/chromeos/login/camera.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_CAMERA_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_CAMERA_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/lock.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 class Task;
 namespace base {
-class TimeDelta;
+class Thread;
 }  // namespace base
 
 namespace chromeos {
 
 // Class that wraps interaction with video capturing device. Returns
 // frames captured with specified intervals of time via delegate interface.
 // All communication with camera driver is performed on a separate camera
 // thread. Delegate's callback are called on UI thread.
 class Camera : public base::RefCountedThreadSafe<Camera> {
  public:
@@ skipping 12 matching lines @@
 
     // Notifies the delegate that new frame was captured.
     // The frame can be obtained via GetFrame() method.
     virtual void OnCaptureSuccess() = 0;
 
     // Notifies the delegate that we failed to capture the next frame.
     virtual void OnCaptureFailure() = 0;
   };
 
   // Initializes object members. |delegate| is object that will receive
-  // notifications about success of async method calls. |mirrored|
-  // determines if the returned video image is mirrored horizontally.
-  Camera(Delegate* delegate, bool mirrored);
+  // notifications about success of async method calls. |thread| is a thread
+  // to post blocking tasks to. |mirrored| determines if the returned video
+  // image is mirrored horizontally.
+  Camera(Delegate* delegate, base::Thread* thread, bool mirrored);
 
   // Initializes camera device on camera thread. Corresponding delegate's
   // callback is called on UI thread to notify about success or failure. Does
   // nothing if camera is successfully initialized already. Sets the desired
   // width and height of the frame to receive from camera.
   void Initialize(int desired_width, int desired_height);
 
   // Uninitializes the camera on camera thread. Can be called anytime, any
   // number of times.
   void Uninitialize();
@@ skipping 39 matching lines @@
   bool ReadFrame();
 
   // Transforms raw data received from camera into SkBitmap with desired
   // size and notifies the delegate that the image is ready.
   void ProcessImage(void* data);
 
   // Actual routines that run on camera thread and call delegate's callbacks.
   // See the corresponding methods without Do prefix for details.
   void DoInitialize(int desired_width, int desired_height);
   void DoStartCapturing();
+  void DoUninitialize();
+  void DoStopCapturing();
 
   // Helper method that reports failure to the delegate via method
   // corresponding to the current state of the object.
   void ReportFailure();
 
   // Methods called on UI thread to call delegate.
   void OnInitializeSuccess();
   void OnInitializeFailure();
   void OnStartCapturingSuccess();
   void OnStartCapturingFailure();
   void OnCaptureSuccess();
   void OnCaptureFailure();
 
-  // Camera thread routines that implement the corresponding public methods.
-  void DoUninitialize();
-  void DoStopCapturing();
-
-  // All methods on the camera thread need to call this to post back to the UI
-  // thread. Otherwise the camera object could be deleted on the camera thread
-  // which is not allowed.
-  void PostCameraThreadAck();
-  void CameraThreadAck();
-
   // Returns true if the code is executed on camera thread right now, false
   // otherwise.
   bool IsOnCameraThread() const;
 
   // Posts task to camera thread.
-  void PostCameraTask(Task* task);
+  void PostCameraTask(const tracked_objects::Location& from_here,
+                      Task* task);
 
   // Defines a buffer in memory where one frame from the camera is stored.
   struct VideoBuffer {
     void* start;
     size_t length;
   };
 
   // Delegate that receives the frames from the camera.
   // Delegate is accessed only on UI thread.
   Delegate* delegate_;
 
   // Thread where all work with the device is going on.
-  base::Thread camera_thread_;
+  base::Thread* thread_;
 
   // All the members below are accessed only on camera thread.
   // Name of the device file, i.e. "/dev/video0".
   std::string device_name_;
 
   // File descriptor of the opened device.
   int device_descriptor_;
 
   // Vector of buffers where to store video frames from camera.
   std::vector<VideoBuffer> buffers_;
@@ skipping 14 matching lines @@
   int frame_height_;
 
   // If set to true, the returned image will be reflected from the Y axis to
   // mimic mirror behavior.
   bool mirrored_;
 
   // Image where camera frames are stored for UI thread to pick up.
   SkBitmap frame_image_;
 
   // Lock that guards references to |frame_image_|.
-  static Lock image_lock_;
+  mutable Lock image_lock_;
 
   // Lock that guards references to |camera_thread_|.
-  static Lock thread_lock_;
+  mutable Lock thread_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(Camera);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_CAMERA_H_