use lock to make sure device will not deliver any frame after it's stopped.

media/video/capture/mac/video_capture_device_mac.mm

 // 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 "media/video/capture/mac/video_capture_device_mac.h"
 
 #import <QTKit/QTKit.h>
 
 #include "base/logging.h"
 #include "base/time.h"
@@ skipping 31 matching lines @@
       state_(kNotInitialized),
       capture_device_(nil) {
 }
 
 VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
   [capture_device_ release];
 }
 
 void VideoCaptureDeviceMac::Allocate(int width, int height, int frame_rate,
                                      EventHandler* observer) {
+  base::AutoLock auto_lock(lock_);
   if (state_ != kIdle) {
     return;
   }
   observer_ = observer;
   NSString* deviceId =
       [NSString stringWithUTF8String:device_name_.unique_id.c_str()];
 
   if (![capture_device_ setCaptureDevice:deviceId]) {
     SetErrorState("Could not open capture device.");
     return;
@@ skipping 16 matching lines @@
 
   observer_->OnFrameInfo(current_settings);
 }
 
 void VideoCaptureDeviceMac::Start() {
   DCHECK_EQ(state_, kAllocated);
   if (![capture_device_ startCapture]) {
     SetErrorState("Could not start capture device.");
     return;
   }
+  base::AutoLock auto_lock(lock_);
   state_ = kCapturing;
 }
 
 void VideoCaptureDeviceMac::Stop() {
   DCHECK_EQ(state_, kCapturing);
   [capture_device_ stopCapture];
+  base::AutoLock auto_lock(lock_);
   state_ = kAllocated;
 }
 
 void VideoCaptureDeviceMac::DeAllocate() {
+  base::AutoLock auto_lock(lock_);
   if (state_ != kAllocated && state_ != kCapturing) {
     return;
   }
   if (state_ == kCapturing) {
     [capture_device_ stopCapture];
   }
   [capture_device_ setCaptureDevice:nil];
   state_ = kIdle;
 }
 
 const VideoCaptureDevice::Name& VideoCaptureDeviceMac::device_name() {
   return device_name_;
 }
 
 bool VideoCaptureDeviceMac::Init() {
   DCHECK_EQ(state_, kNotInitialized);
 
   Names device_names;
   GetDeviceNames(&device_names);
   for (Names::iterator it = device_names.begin();
        it != device_names.end();
        ++it) {
     if (device_name_.unique_id == it->unique_id) {
       capture_device_ =
           [[VideoCaptureDeviceQTKit alloc] initWithFrameReceiver:this];
       if (!capture_device_) {
         return false;
       }
       state_ = kIdle;

[Ronghua Wu (Left Chromium), 2012/09/06 20:48:38]

Do we need the lock here?

[wjia(left Chromium), 2012/09/06 20:59:15]

Init() is called only when the instance is created. There would be no racing
here.

       return true;
     }
   }
   return false;
 }
 
 void VideoCaptureDeviceMac::ReceiveFrame(
     const uint8* video_frame,
     int video_frame_length,
     const VideoCaptureCapability& frame_info) {
-  observer_->OnIncomingCapturedFrame(video_frame, video_frame_length,
-                                     base::Time::Now());
+  base::AutoLock auto_lock(lock_);
+  if (state_ == kCapturing) {
+    observer_->OnIncomingCapturedFrame(video_frame, video_frame_length,
+                                       base::Time::Now());
+  }
 }
 
 void VideoCaptureDeviceMac::SetErrorState(const std::string& reason) {
   DLOG(ERROR) << reason;
+  base::AutoLock auto_lock(lock_);
   state_ = kError;
   observer_->OnError();
 }
 
 } // namespace media