Pace outgoing frames in frame scheduler to match target bitrate.

remoting/test/fake_socket_factory.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "remoting/test/fake_socket_factory.h"
 
+#include <algorithm>
 #include <cmath>
 #include <cstddef>
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/io_buffer.h"
-#include "remoting/test/leaky_bucket.h"
+#include "remoting/base/leaky_bucket.h"
 #include "third_party/webrtc/base/asyncpacketsocket.h"
 #include "third_party/webrtc/base/socket.h"
 #include "third_party/webrtc/media/base/rtputils.h"
 
 namespace remoting {
 
 namespace {
 
 const int kPortRangeStart = 1024;
 const int kPortRangeEnd = 65535;
@@ skipping 82 matching lines @@
                         const rtc::PacketOptions& options) {
   NOTREACHED();
   return EINVAL;
 }
 
 int FakeUdpSocket::SendTo(const void* data, size_t data_size,
                           const rtc::SocketAddress& address,
                           const rtc::PacketOptions& options) {
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(data_size);
   memcpy(buffer->data(), data, data_size);
-  cricket::ApplyPacketOptions(
-      reinterpret_cast<uint8_t*>(buffer->data()), data_size,
-      options.packet_time_params,
-      (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds());
+  base::TimeTicks now = base::TimeTicks::Now();
+  cricket::ApplyPacketOptions(reinterpret_cast<uint8_t*>(buffer->data()),
+                              data_size, options.packet_time_params,
+                              (now - base::TimeTicks()).InMicroseconds());
   SignalSentPacket(
-      this, rtc::SentPacket(options.packet_id, (base::TimeTicks::Now() -
-                                                base::TimeTicks::UnixEpoch())
-                                                   .InMilliseconds()));
+      this,
+      rtc::SentPacket(options.packet_id,
+                      (now - base::TimeTicks::UnixEpoch()).InMilliseconds()));
   dispatcher_->DeliverPacket(local_address_, address, buffer, data_size);
   return data_size;
 }
 
 int FakeUdpSocket::Close() {
   state_ = STATE_CLOSED;
   return 0;
 }
 
 rtc::AsyncPacketSocket::State FakeUdpSocket::GetState() const {
@@ skipping 145 matching lines @@
     const rtc::SocketAddress& from,
     const rtc::SocketAddress& to,
     const scoped_refptr<net::IOBuffer>& data,
     int data_size) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(to.ipaddr() == address_);
 
   base::TimeDelta delay;
 
   if (leaky_bucket_) {
-    delay = leaky_bucket_->AddPacket(data_size);
-    if (delay.is_max()) {
+    base::TimeTicks now = base::TimeTicks::Now();
+    if (!leaky_bucket_->RefillOrSpill(data_size, now)) {
       ++total_packets_dropped_;
       // Drop the packet.
       return;
     }
+    delay = std::max(base::TimeDelta(), leaky_bucket_->GetEmptyTime() - now);
   }
 
   total_buffer_delay_ += delay;
   if (delay > max_buffer_delay_)
     max_buffer_delay_ = delay;
   ++total_packets_received_;
 
   if (latency_average_ > base::TimeDelta()) {
     delay += base::TimeDelta::FromMillisecondsD(
         GetNormalRandom(latency_average_.InMillisecondsF(),
@@ skipping 41 matching lines @@
 }
 
 void FakePacketSocketFactory::ResetStats() {
   total_packets_dropped_ = 0;
   total_packets_received_ = 0;
   total_buffer_delay_ = base::TimeDelta();
   max_buffer_delay_ = base::TimeDelta();
 }
 
 }  // namespace remoting