getUserMeida: report device starting states

media/capture/video/fake_video_capture_device.cc

 // 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/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 79 matching lines @@
   void DrawPacman(base::TimeDelta elapsed_time, uint8_t* target_buffer);
 
   const VideoPixelFormat pixel_format_;
   const FakeDeviceState* fake_device_state_ = nullptr;
 };
 
 // Paints and delivers frames to a client, which is set via Initialize().
 class FrameDeliverer {
  public:
   FrameDeliverer(std::unique_ptr<PacmanFramePainter> frame_painter)
-      : frame_painter_(std::move(frame_painter)) {}
+      : frame_painter_(std::move(frame_painter)), capture_(false) {}
   virtual ~FrameDeliverer() {}
   virtual void Initialize(VideoPixelFormat pixel_format,
                           std::unique_ptr<VideoCaptureDevice::Client> client,
                           const FakeDeviceState* device_state) = 0;
   virtual void Uninitialize() = 0;
   virtual void PaintAndDeliverNextFrame(base::TimeDelta timestamp_to_paint) = 0;
 
  protected:
   base::TimeDelta CalculateTimeSinceFirstInvocation(base::TimeTicks now) {
     if (first_ref_time_.is_null())
       first_ref_time_ = now;
     return now - first_ref_time_;
   }
 
   const std::unique_ptr<PacmanFramePainter> frame_painter_;
   const FakeDeviceState* device_state_ = nullptr;
   std::unique_ptr<VideoCaptureDevice::Client> client_;
+  bool capture_;
 
  private:
   base::TimeTicks first_ref_time_;
 };
 
 // Delivers frames using its own buffers via OnIncomingCapturedData().
 class OwnBufferFrameDeliverer : public FrameDeliverer {
  public:
   OwnBufferFrameDeliverer(std::unique_ptr<PacmanFramePainter> frame_painter);
   ~OwnBufferFrameDeliverer() override;
@@ skipping 393 matching lines @@
 OwnBufferFrameDeliverer::~OwnBufferFrameDeliverer() = default;
 
 void OwnBufferFrameDeliverer::Initialize(
     VideoPixelFormat pixel_format,
     std::unique_ptr<VideoCaptureDevice::Client> client,
     const FakeDeviceState* device_state) {
   client_ = std::move(client);
   device_state_ = device_state;
   buffer_.reset(new uint8_t[VideoFrame::AllocationSize(
       pixel_format, device_state_->format.frame_size)]);
+  client_->OnStarted();
+  capture_ = true;
 }
 
 void OwnBufferFrameDeliverer::Uninitialize() {
+  capture_ = false;
   client_.reset();
   device_state_ = nullptr;
   buffer_.reset();
 }
 
 void OwnBufferFrameDeliverer::PaintAndDeliverNextFrame(
     base::TimeDelta timestamp_to_paint) {
-  if (!client_)
+  if (!client_ || !capture_)
     return;
   const size_t frame_size = device_state_->format.ImageAllocationSize();
   memset(buffer_.get(), 0, frame_size);
   frame_painter_->PaintFrame(timestamp_to_paint, buffer_.get());
   base::TimeTicks now = base::TimeTicks::Now();
   client_->OnIncomingCapturedData(buffer_.get(), frame_size,
                                   device_state_->format, 0 /* rotation */, now,
                                   CalculateTimeSinceFirstInvocation(now));
 }
 
 ClientBufferFrameDeliverer::ClientBufferFrameDeliverer(
     std::unique_ptr<PacmanFramePainter> frame_painter)
     : FrameDeliverer(std::move(frame_painter)) {}
 
 ClientBufferFrameDeliverer::~ClientBufferFrameDeliverer() = default;
 
 void ClientBufferFrameDeliverer::Initialize(
     VideoPixelFormat,
     std::unique_ptr<VideoCaptureDevice::Client> client,
     const FakeDeviceState* device_state) {
   client_ = std::move(client);
   device_state_ = device_state;
+  client_->OnStarted();
 }
 
 void ClientBufferFrameDeliverer::Uninitialize() {
   client_.reset();
   device_state_ = nullptr;
 }
 
 void ClientBufferFrameDeliverer::PaintAndDeliverNextFrame(
     base::TimeDelta timestamp_to_paint) {
   if (client_ == nullptr)
@@ skipping 56 matching lines @@
     int session_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (session_id != current_session_id_)
     return;
 
   frame_deliverer_->PaintAndDeliverNextFrame(elapsed_time_);
   BeepAndScheduleNextCapture(expected_execution_time);
 }
 
 }  // namespace media