getUserMeida: report device starting states

media/capture/content/thread_safe_capture_oracle.cc

 // Copyright 2014 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/content/thread_safe_capture_oracle.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 27 matching lines @@
     std::unique_ptr<VideoCaptureDevice::Client> client,
     const VideoCaptureParams& params,
     bool enable_auto_throttling)
     : client_(std::move(client)),
       oracle_(base::TimeDelta::FromMicroseconds(static_cast<int64_t>(
                   1000000.0 / params.requested_format.frame_rate +
                   0.5 /* to round to nearest int */)),
               params.requested_format.frame_size,
               params.resolution_change_policy,
               enable_auto_throttling),
-      params_(params) {}
+      params_(params),
+      capture_(false) {}
 
 ThreadSafeCaptureOracle::~ThreadSafeCaptureOracle() {
 }
 
 bool ThreadSafeCaptureOracle::ObserveEventAndDecideCapture(
     VideoCaptureOracle::Event event,
     const gfx::Rect& damage_rect,
     base::TimeTicks event_time,
     scoped_refptr<VideoFrame>* storage,
     CaptureFrameCallback* callback) {
@@ skipping 121 matching lines @@
 }
 
 void ThreadSafeCaptureOracle::UpdateCaptureSize(const gfx::Size& source_size) {
   base::AutoLock guard(lock_);
   VLOG(1) << "Source size changed to " << source_size.ToString();
   oracle_.SetSourceSize(source_size);
 }
 
 void ThreadSafeCaptureOracle::Stop() {
   base::AutoLock guard(lock_);
+  capture_ = false;
   client_.reset();
 }
 
 void ThreadSafeCaptureOracle::ReportError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   base::AutoLock guard(lock_);
   if (client_)
     client_->OnError(from_here, reason);
 }
 
+void ThreadSafeCaptureOracle::ReportStarted() {
+  base::AutoLock guard(lock_);
+  if (client_)
+    client_->OnStarted();
+  capture_ = true;
+}
+
 void ThreadSafeCaptureOracle::DidCaptureFrame(
     int frame_number,
     VideoCaptureDevice::Client::Buffer buffer,
     base::TimeTicks capture_begin_time,
     base::TimeDelta estimated_frame_duration,
     scoped_refptr<VideoFrame> frame,
     base::TimeTicks reference_time,
     bool success) {
   TRACE_EVENT_ASYNC_END2("gpu.capture", "Capture", buffer.id(), "success",
                          success, "timestamp",
                          reference_time.ToInternalValue());
 
   base::AutoLock guard(lock_);
 
   if (!oracle_.CompleteCapture(frame_number, success, &reference_time))
     return;
 
   TRACE_EVENT_INSTANT0("gpu.capture", "CaptureSucceeded",
                        TRACE_EVENT_SCOPE_THREAD);
 
-  if (!client_)
+  if (!client_ || !capture_)

[miu, 2017/02/18 01:18:45]

Dropping frames at this stage could break things (there were several similar
bugs in the past related to dropping frames).

I thought about this whole change a bit more, and I'm not convinced this is the
right overall approach to solving the problem (as I understand it).

I think you should remove this logic (and in all the other VCD impls). We
shouldn't require that OnStarted() be called before any frames can be delivered.
This requirement was never necessary before. Instead, the API contract was that
frames could be delivered at any point once AllocateAndStart() is called.

If it is a requirement for gUM, then gUM should drop frames at the consumer end.
But, that might be a very bad idea: dropping *any* frames can break things
because not all VCD's continuously produce frames. In other words, there are
start-up scenarios where a producer will send only one frame and then no others
for a long period of time, and if that first frame is dropped, consumers will
never see a first frame. (again, there were bugs relating to this)

Stepping back, I wonder if it'd be simpler to just scrap all the browser-side
changes. Remove OnStarted() altogether. Instead, in the render process, could
gUM simply infer that receiving a first frame means the capture device
successfully started? The web platform event for "started capture" could be
dispatched at the time the first frame arrives at the consumer.

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

Acknowledged.

     return;  // Capture is stopped.
 
   frame->metadata()->SetDouble(VideoFrameMetadata::FRAME_RATE,
                                params_.requested_format.frame_rate);
   frame->metadata()->SetTimeTicks(VideoFrameMetadata::CAPTURE_BEGIN_TIME,
                                   capture_begin_time);
   frame->metadata()->SetTimeTicks(VideoFrameMetadata::CAPTURE_END_TIME,
                                   base::TimeTicks::Now());
   frame->metadata()->SetTimeDelta(VideoFrameMetadata::FRAME_DURATION,
                                   estimated_frame_duration);
@@ skipping 10 matching lines @@
 }
 
 void ThreadSafeCaptureOracle::OnConsumerReportingUtilization(
     int frame_number,
     double utilization) {
   base::AutoLock guard(lock_);
   oracle_.RecordConsumerFeedback(frame_number, utilization);
 }
 
 }  // namespace media