Fixing issue that causes STUN throttle rate to be off by a factor of 1000.

content/browser/renderer_host/p2p/socket_host_udp_unittest.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 "content/browser/renderer_host/p2p/socket_host_udp.h"
 
 #include <stdint.h>
 #include <deque>
 #include <utility>
 #include <vector>
@@ skipping 12 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::Return;
 
 namespace {
 
 // TODO(nisse): We can't currently use rtc::ScopedFakeClock, because
-// we don't link with webrtc rtc_base_tests_utils. So roll our own,
-// for the special case of a clock standing still at zero.
+// we don't link with webrtc rtc_base_tests_utils. So roll our own.
 
 // Creating an object of this class makes rtc::TimeMicros() and
-// related functions return zero for the lifetime of the object.
-class ScopedFakeZeroClock : public rtc::ClockInterface {
+// related functions return zero unless the clock is advanced.
+class ScopedFakeClock : public rtc::ClockInterface {
  public:
-  ScopedFakeZeroClock() {
-    prev_clock_ = rtc::SetClockForTesting(this);
-  }
-  ~ScopedFakeZeroClock() override {
-    rtc::SetClockForTesting(prev_clock_);
-  }
+  ScopedFakeClock() { prev_clock_ = rtc::SetClockForTesting(this); }
+  ~ScopedFakeClock() override { rtc::SetClockForTesting(prev_clock_); }
   // ClockInterface implementation.
-  uint64_t TimeNanos() const override {
-    return 0;
-  }
+  uint64_t TimeNanos() const override { return time_nanos_; }
+  void SetTimeNanos(uint64_t time_nanos) { time_nanos_ = time_nanos; }
+
  private:
   ClockInterface* prev_clock_;
+  uint64_t time_nanos_ = 0;
 };
 
 class FakeDatagramServerSocket : public net::DatagramServerSocket {
  public:
   typedef std::pair<net::IPEndPoint, std::vector<char> > UDPPacket;
 
   // P2PSocketHostUdp destroys a socket on errors so sent packets
   // need to be stored outside of this object.
   FakeDatagramServerSocket(std::deque<UDPPacket>* sent_packets,
                            std::vector<uint16_t>* used_ports)
@@ skipping 161 matching lines @@
     dest1_ = ParseAddress(kTestIpAddress1, kTestPort1);
     dest2_ = ParseAddress(kTestIpAddress2, kTestPort2);
   }
 
   static FakeDatagramServerSocket* GetSocketFromHost(
       P2PSocketHostUdp* socket_host) {
     return static_cast<FakeDatagramServerSocket*>(socket_host->socket_.get());
   }
 
   P2PMessageThrottler throttler_;
-  ScopedFakeZeroClock fake_clock_;
+  ScopedFakeClock fake_clock_;
   std::deque<FakeDatagramServerSocket::UDPPacket> sent_packets_;
   FakeDatagramServerSocket* socket_;  // Owned by |socket_host_|.
   std::unique_ptr<P2PSocketHostUdp> socket_host_;
   MockIPCSender sender_;
 
   net::IPEndPoint local_address_;
 
   net::IPEndPoint dest1_;
   net::IPEndPoint dest2_;
 };
@@ skipping 169 matching lines @@
   // This packet will be dropped, as limit only for a single packet.
   socket_host_->Send(dest3, packet1, options, 0);
   net::IPEndPoint dest4 = ParseAddress(kTestIpAddress1, 2224);
   // This packet should also be dropped.
   socket_host_->Send(dest4, packet1, options, 0);
   // |dest1| is known, we can send as many packets to it.
   socket_host_->Send(dest1_, packet1, options, 0);
   ASSERT_EQ(sent_packets_.size(), 4U);
 }
 
+// The fake clock mechanism used for this test doesn't work in component builds.
+// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=6490
+#if defined(COMPONENT_BUILD)
+#define MAYBE_ThrottlingStopsAtExpectedTimes DISABLED_ThrottlingStopsAtExpectedTimes
+#else
+#define MAYBE_ThrottlingStopsAtExpectedTimes ThrottlingStopsAtExpectedTimes
+#endif
+// Test that once the limit is hit, the throttling stops at the expected time,
+// allowing packets to be sent again.
+TEST_F(P2PSocketHostUdpTest, MAYBE_ThrottlingStopsAtExpectedTimes) {
+  EXPECT_CALL(
+      sender_,
+      Send(MatchMessage(static_cast<uint32_t>(P2PMsg_OnSendComplete::ID))))
+      .Times(12)
+      .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
+
+  rtc::PacketOptions options;
+  std::vector<char> packet;
+  CreateStunRequest(&packet);
+  // Limit of 2 packets per second.
+  throttler_.SetSendIceBandwidth(packet.size() * 2);
+  socket_host_->Send(dest1_, packet, options, 0);
+  socket_host_->Send(dest2_, packet, options, 0);
+  EXPECT_EQ(2U, sent_packets_.size());
+
+  // These packets must be dropped by the throttler since the limit was hit and
+  // the time hasn't advanced.
+  socket_host_->Send(dest1_, packet, options, 0);
+  socket_host_->Send(dest2_, packet, options, 0);
+  EXPECT_EQ(2U, sent_packets_.size());
+
+  // Advance the time to 0.999 seconds; throttling should still just barely be
+  // active.
+  fake_clock_.SetTimeNanos(rtc::kNumNanosecsPerMillisec * 999);
+  socket_host_->Send(dest1_, packet, options, 0);
+  socket_host_->Send(dest2_, packet, options, 0);
+  EXPECT_EQ(2U, sent_packets_.size());
+
+  // After hitting the second mark, we should be able to send again.
+  // Add an extra millisecond to account for rounding errors.
+  fake_clock_.SetTimeNanos(rtc::kNumNanosecsPerMillisec * 1001);
+  socket_host_->Send(dest1_, packet, options, 0);
+  EXPECT_EQ(3U, sent_packets_.size());
+
+  // This time, hit the limit in the middle of the period.
+  fake_clock_.SetTimeNanos(rtc::kNumNanosecsPerMillisec * 1500);
+  socket_host_->Send(dest2_, packet, options, 0);
+  EXPECT_EQ(4U, sent_packets_.size());
+
+  // Again, throttling should be active until the next second mark.
+  fake_clock_.SetTimeNanos(rtc::kNumNanosecsPerMillisec * 1999);
+  socket_host_->Send(dest1_, packet, options, 0);
+  socket_host_->Send(dest2_, packet, options, 0);
+  EXPECT_EQ(4U, sent_packets_.size());
+  fake_clock_.SetTimeNanos(rtc::kNumNanosecsPerMillisec * 2002);
+  socket_host_->Send(dest1_, packet, options, 0);
+  socket_host_->Send(dest2_, packet, options, 0);
+  EXPECT_EQ(6U, sent_packets_.size());
+}
+
 // Verify that we can open UDP sockets listening in a given port range,
 // and fail if all ports in the range are already in use.
 TEST_F(P2PSocketHostUdpTest, PortRangeImplicitPort) {
   const uint16_t min_port = 10000;
   const uint16_t max_port = 10001;
   std::deque<FakeDatagramServerSocket::UDPPacket> sent_packets;
   std::vector<uint16_t> used_ports;
   P2PSocketHostUdp::DatagramServerSocketFactory fake_socket_factory =
       base::Bind(&CreateFakeDatagramServerSocket, &sent_packets, &used_ports);
   P2PMessageThrottler throttler;
@@ skipping 78 matching lines @@
   std::unique_ptr<P2PSocketHostUdp> socket_host(
       new P2PSocketHostUdp(&sender, 0, &throttler, fake_socket_factory));
   net::IPEndPoint local_address =
       ParseAddress(kTestLocalIpAddress, invalid_port);
   bool rv = socket_host->Init(local_address, min_port, max_port,
                               P2PHostAndIPEndPoint());
   EXPECT_FALSE(rv);
 }
 
 }  // namespace content