Fix WebRtcFrameScheduler to wait for first key frame request.

remoting/protocol/webrtc_frame_scheduler.cc

 // Copyright 2016 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 "remoting/protocol/webrtc_frame_scheduler.h"
 
 #include <algorithm>
 #include <memory>
 
+#include "base/location.h"

[Irfan, 2016/06/02 19:06:00]

what is this used for ?

[Sergey Ulanov, 2016/06/03 06:01:23]

it defines FROM_HERE macro used for PostTask()

 #include "base/logging.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "remoting/base/constants.h"
 #include "remoting/proto/video.pb.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 // Target quantizer at which stop the encoding top-off.
 const int kTargetQuantizerForTopOff = 30;
@@ skipping 10 matching lines @@
 // at 30 FPS to capture, encode and send frames over webrtc transport.
 // An improved solution will use target bitrate feedback to pace out
 // the capture rate.
 WebRtcFrameScheduler::WebRtcFrameScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     std::unique_ptr<webrtc::DesktopCapturer> capturer,
     WebrtcTransport* webrtc_transport,
     std::unique_ptr<VideoEncoder> encoder)
     : target_bitrate_kbps_(kDefaultTargetBitrateKbps),
       last_quantizer_(kMaxQuantizer),
+      main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       encode_task_runner_(encode_task_runner),
       capturer_(std::move(capturer)),
       webrtc_transport_(webrtc_transport),
       encoder_(std::move(encoder)),
       weak_factory_(this) {
   DCHECK(encode_task_runner_);
   DCHECK(capturer_);
   DCHECK(webrtc_transport_);
   DCHECK(encoder_);
   // Does not really start anything. Registers callback on this class.
   capturer_->Start(this);
   capture_timer_.reset(new base::RepeatingTimer());
 }
 
 WebRtcFrameScheduler::~WebRtcFrameScheduler() {
   encode_task_runner_->DeleteSoon(FROM_HERE, encoder_.release());
 }
 
 void WebRtcFrameScheduler::Start() {
   // Register for PLI requests.
   webrtc_transport_->video_encoder_factory()->SetKeyFrameRequestCallback(
       base::Bind(&WebRtcFrameScheduler::SetKeyFrameRequest,
                  base::Unretained(this)));
   // Register for target bitrate notifications.
   webrtc_transport_->video_encoder_factory()->SetTargetBitrateCallback(
       base::Bind(&WebRtcFrameScheduler::SetTargetBitrate,
                  base::Unretained(this)));
-  capture_timer_->Start(FROM_HERE, base::TimeDelta::FromSeconds(1) / 30, this,
-                        &WebRtcFrameScheduler::CaptureNextFrame);
 }
 
 void WebRtcFrameScheduler::Stop() {
   // Clear PLI request callback.
   webrtc_transport_->video_encoder_factory()->SetKeyFrameRequestCallback(
       base::Closure());
   webrtc_transport_->video_encoder_factory()->SetTargetBitrateCallback(
       TargetBitrateCallback());
   // Cancel any pending encode.
   task_tracker_.TryCancelAll();
@@ skipping 10 matching lines @@
 
 void WebRtcFrameScheduler::SetSizeCallback(
     const VideoStream::SizeCallback& callback) {
   size_callback_ = callback;
 }
 
 void WebRtcFrameScheduler::SetKeyFrameRequest() {
   VLOG(1) << "Request key frame";
   base::AutoLock lock(lock_);
   key_frame_request_ = true;
+  if (!received_first_frame_request_) {
+    received_first_frame_request_ = true;
+    main_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&WebRtcFrameScheduler::StartCaptureTimer,
+                              weak_factory_.GetWeakPtr()));
+  }
+}
+
+void WebRtcFrameScheduler::StartCaptureTimer() {
+  capture_timer_->Start(FROM_HERE, base::TimeDelta::FromSeconds(1) / 30, this,
+                        &WebRtcFrameScheduler::CaptureNextFrame);
 }
 
 void WebRtcFrameScheduler::SetTargetBitrate(int target_bitrate_kbps) {
   VLOG(1) << "Set Target bitrate " << target_bitrate_kbps;
   base::AutoLock lock(lock_);
   target_bitrate_kbps_ = target_bitrate_kbps;
 }
 
 bool WebRtcFrameScheduler::ClearAndGetKeyFrameRequest() {
   base::AutoLock lock(lock_);
@@ skipping 13 matching lines @@
   std::unique_ptr<webrtc::DesktopFrame> owned_frame(frame);
 
   if (encode_pending_) {
     // TODO(isheriff): consider queuing here
     VLOG(1) << "Dropping captured frame since encoder is still busy";
     return;
   }
 
   // If unchanged and does not need top-off, return.
   if (!frame || (frame->updated_region().is_empty() &&
-                 last_quantizer_ <= kTargetQuantizerForTopOff))
+                 last_quantizer_ <= kTargetQuantizerForTopOff)) {
     return;
+  }
 
   last_capture_completed_ticks_ = captured_ticks;
 
   webrtc::DesktopVector dpi =
       frame->dpi().is_zero() ? webrtc::DesktopVector(kDefaultDpi, kDefaultDpi)
                              : frame->dpi();
 
   if (!frame_size_.equals(frame->size()) || !frame_dpi_.equals(dpi)) {
     frame_size_ = frame->size();
     frame_dpi_ = dpi;
@@ skipping 10 matching lines @@
                  weak_factory_.GetWeakPtr()));
 }
 
 void WebRtcFrameScheduler::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (capture_pending_ || encode_pending_) {
     VLOG(1) << "Capture/encode still pending..";
     return;
   }
+
   capture_pending_ = true;
   VLOG(1) << "Capture next frame after "
           << (base::TimeTicks::Now() - last_capture_started_ticks_)
                  .InMilliseconds();
   last_capture_started_ticks_ = base::TimeTicks::Now();
   capturer_->Capture(webrtc::DesktopRegion());
 }
 
 // static
 std::unique_ptr<VideoPacket> WebRtcFrameScheduler::EncodeFrame(
@@ skipping 28 matching lines @@
   encode_pending_ = false;
   if (!packet)
     return;
   last_quantizer_ = packet->quantizer();
   base::TimeTicks current = base::TimeTicks::Now();
   uint32_t encoded_bits = packet->data().size() * 8.0;
 
   // Simplistic adaptation of frame polling in the range 5 FPS to 30 FPS.
   uint32_t next_sched_ms = std::max(
       33, std::min(static_cast<int>(encoded_bits / target_bitrate_kbps_), 200));
-  // TODO(isheriff): Investigate why first frame fails to send at times.
-  // This gets resolved through a PLI request.
   if (webrtc_transport_->video_encoder_factory()->SendEncodedFrame(
           std::move(packet)) >= 0) {
     VLOG(1) << " Send duration "
             << (base::TimeTicks::Now() - current).InMilliseconds()
             << "next sched " << next_sched_ms;
   } else {
     LOG(ERROR) << "SendEncodedFrame() failed";
   }
   capture_timer_->Start(FROM_HERE,
                         base::TimeDelta::FromMilliseconds(next_sched_ms), this,
                         &WebRtcFrameScheduler::CaptureNextFrame);
 }
 
 }  // namespace protocol
 }  // namespace remoting