Add remoting::protocol::NetworkStateObserver interface.

remoting/protocol/webrtc_frame_scheduler_simple.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_simple.h"
 
 #include <algorithm>
 
+#include "remoting/protocol/webrtc_dummy_video_encoder.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 // Number of samples used to estimate processing time for the next frame.
 const int kStatsWindow = 5;
 
@@ skipping 30 matching lines @@
     result += r.rect().width() * r.rect().height();
   }
   return result;
 }
 
 }  // namespace
 
 WebrtcFrameSchedulerSimple::WebrtcFrameSchedulerSimple()
     : pacing_bucket_(LeakyBucket::kUnlimitedDepth, 0),
       frame_processing_delay_us_(kStatsWindow),
-      updated_region_area_(kStatsWindow) {}
+      updated_region_area_(kStatsWindow),
+      weak_factory_(this) {}
 WebrtcFrameSchedulerSimple::~WebrtcFrameSchedulerSimple() {}
 
-void WebrtcFrameSchedulerSimple::Start(const base::Closure& capture_callback) {
+void WebrtcFrameSchedulerSimple::OnKeyFrameRequested() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  key_frame_request_ = true;
+  if (!capture_timer_.IsRunning())
+    ScheduleNextFrame(base::TimeTicks::Now());
+}
+
+void WebrtcFrameSchedulerSimple::OnChannelParameters(int packet_loss,
+                                                     base::TimeDelta rtt) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+void WebrtcFrameSchedulerSimple::OnTargetBitrateChanged(int bitrate_kbps) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::TimeTicks now = base::TimeTicks::Now();
+  pacing_bucket_.UpdateRate(bitrate_kbps * 1000 / 8, now);
+  ScheduleNextFrame(now);
+}
+
+void WebrtcFrameSchedulerSimple::Start(
+    WebrtcDummyVideoEncoderFactory* video_encoder_factory,
+    const base::Closure& capture_callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   capture_callback_ = capture_callback;
-  ScheduleNextFrame(base::TimeTicks::Now());
+  video_encoder_factory->SetVideoChannelStateObserver(
+      weak_factory_.GetWeakPtr());
 }
 
 void WebrtcFrameSchedulerSimple::Pause(bool pause) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   paused_ = pause;
   if (paused_) {
     capture_timer_.Stop();
   } else {
     ScheduleNextFrame(base::TimeTicks::Now());
   }
 }
 
-void WebrtcFrameSchedulerSimple::SetKeyFrameRequest() {
-  key_frame_request_ = true;
-}
-
-void WebrtcFrameSchedulerSimple::SetTargetBitrate(int bitrate_kbps) {
-  base::TimeTicks now = base::TimeTicks::Now();
-  pacing_bucket_.UpdateRate(bitrate_kbps * 1000 / 8, now);
-  ScheduleNextFrame(now);
-}
-
 bool WebrtcFrameSchedulerSimple::GetEncoderFrameParams(
     const webrtc::DesktopFrame& frame,
     WebrtcVideoEncoder::FrameParams* params_out) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   base::TimeTicks now = base::TimeTicks::Now();
 
   if (frame.updated_region().is_empty() && !top_off_is_active_ &&
       !key_frame_request_) {
     ScheduleNextFrame(now);
     return false;
   }
 
   // TODO(sergeyu): This logic is applicable only to VP8. Reconsider it for VP9.
   int minimum_bitrate =
@@ skipping 31 matching lines @@
   params_out->vpx_max_quantizer = 63;
 
   params_out->clear_active_map = !top_off_is_active_;
 
   return true;
 }
 
 void WebrtcFrameSchedulerSimple::OnFrameEncoded(
     const WebrtcVideoEncoder::EncodedFrame& encoded_frame,
     const webrtc::EncodedImageCallback::Result& send_result) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   base::TimeTicks now = base::TimeTicks::Now();
   pacing_bucket_.RefillOrSpill(encoded_frame.data.size(), now);
 
   if (encoded_frame.data.empty()) {
     top_off_is_active_ = false;
   } else {
     frame_processing_delay_us_.Record(
         (now - last_capture_started_time_).InMicroseconds());
 
     // Top-off until the target quantizer value is reached.
     top_off_is_active_ = encoded_frame.quantizer > kTargetQuantizerForVp8TopOff;
   }
 
   ScheduleNextFrame(now);
 }
 
 void WebrtcFrameSchedulerSimple::ScheduleNextFrame(base::TimeTicks now) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   // Don't capture frames when paused or target bitrate is 0 or there is
   // no capture callback set.
   if (paused_ || pacing_bucket_.rate() == 0 || capture_callback_.is_null())
     return;
 
   // If this is not the first frame then capture next frame after the previous
   // one has finished sending.
   base::TimeDelta expected_processing_time =
       base::TimeDelta::FromMicroseconds(frame_processing_delay_us_.Max());
   base::TimeTicks target_capture_time =
       pacing_bucket_.GetEmptyTime() - expected_processing_time;
 
   // Cap interval between frames to kTargetFrameInterval.
   if (!last_capture_started_time_.is_null()) {
     target_capture_time = std::max(
         target_capture_time, last_capture_started_time_ + kTargetFrameInterval);
   }
 
   if (target_capture_time < now)
     target_capture_time = now;
 
   capture_timer_.Start(FROM_HERE, target_capture_time - now,
                        base::Bind(&WebrtcFrameSchedulerSimple::CaptureNextFrame,
                                   base::Unretained(this)));
 }
 
 void WebrtcFrameSchedulerSimple::CaptureNextFrame() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   last_capture_started_time_ = base::TimeTicks::Now();
   capture_callback_.Run();
 }
 
 }  // namespace protocol
 }  // namespace remoting