getUserMeida: report device starting states

media/capture/video/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/capture/video/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 #include <stddef.h>
@@ skipping 341 matching lines @@
       SetAntiFlickerInUsbDevice(vendor_id_as_int, model_id_as_int,
                                 GetPowerLineFrequency(params));
     }
   }
 
   if (![capture_device_ startCapture]) {
     SetErrorState(FROM_HERE, "Could not start capture device.");
     return;
   }
 
+  client_->OnStarted();
   state_ = kCapturing;
 }
 
 void VideoCaptureDeviceMac::StopAndDeAllocate() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == kCapturing || state_ == kError) << state_;
 
   [capture_device_ setCaptureDevice:nil];
   [capture_device_ setFrameReceiver:nil];
   client_.reset();
@@ skipping 27 matching lines @@
   state_ = kIdle;
   return true;
 }
 
 void VideoCaptureDeviceMac::ReceiveFrame(const uint8_t* video_frame,
                                          int video_frame_length,
                                          const VideoCaptureFormat& frame_format,
                                          int aspect_numerator,
                                          int aspect_denominator,
                                          base::TimeDelta timestamp) {
+  if (state_ != kCapturing)

[chfremer, 2017/02/17 23:51:15]

Unless this runs on the same thread as AllocateAndStart(), this check may happen
concurrently with AllocateAndStart() changing |state_| to kCapturing. I don't
know if this is a legal atomic operation or if it needs to be synchronized using
locks. Could you please check/confirm?

[braveyao, 2017/02/22 18:06:44]

Done.
Tried to apply std::atomic<> to all other places.

+    return;
+
   if (capture_format_.frame_size != frame_format.frame_size) {
     ReceiveError(FROM_HERE,
                  "Captured resolution " + frame_format.frame_size.ToString() +
                      ", and expected " + capture_format_.frame_size.ToString());
     return;
   }
 
   client_->OnIncomingCapturedData(video_frame, video_frame_length, frame_format,
                                   0, base::TimeTicks::Now(), timestamp);
 }
@@ skipping 69 matching lines @@
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
     ReceiveError(FROM_HERE, "Could not configure capture device.");
     return false;
   }
   return true;
 }
 
 }  // namespace media