Parse FlexFEC RTP headers in Call and add integration with BWE.

webrtc/modules/congestion_controller/congestion_controller_unittest.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/congestion_controller/include/mock/mock_congestion_controller.h"
 #include "webrtc/modules/pacing/mock/mock_paced_sender.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::NiceMock;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
+namespace {
+
+// Helper to convert some time format to resolution used in absolute send time
+// header extension, rounded upwards. |t| is the time to convert, in some
+// resolution. |denom| is the value to divide |t| by to get whole seconds,
+// e.g. |denom| = 1000 if |t| is in milliseconds.
+uint32_t AbsSendTime(int64_t t, int64_t denom) {
+  return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful;
+}
+
+}  // namespace
+
 namespace webrtc {
 namespace test {
 
 class CongestionControllerTest : public ::testing::Test {
  protected:
   CongestionControllerTest() : clock_(123456) {}
   ~CongestionControllerTest() override {}
 
   void SetUp() override {
     pacer_ = new NiceMock<MockPacedSender>();
@@ skipping 155 matching lines @@
   clock_.AdvanceTimeMilliseconds(25);
   controller_->Process();
 
   EXPECT_CALL(observer_, OnNetworkChanged(_, _, _, testing::Ne(0)));
   EXPECT_CALL(*pacer_, SetEstimatedBitrate(_));
   bandwidth_observer_->OnReceivedEstimatedBitrate(kInitialBitrateBps * 2);
   clock_.AdvanceTimeMilliseconds(25);
   controller_->Process();
 }
 
+TEST_F(CongestionControllerTest, OnReceivedPacketWithAbsSendTime) {
+  NiceMock<MockCongestionObserver> observer;
+  StrictMock<MockRemoteBitrateObserver> remote_bitrate_observer;
+  std::unique_ptr<PacedSender> pacer(new NiceMock<MockPacedSender>());
+  controller_.reset(
+      new CongestionController(&clock_, &observer, &remote_bitrate_observer,
+                               &event_log_, &packet_router_, std::move(pacer)));
+
+  size_t payload_size = 1000;
+  RTPHeader header;
+  header.ssrc = 0x11eb21c;
+  header.extension.hasAbsoluteSendTime = true;
+
+  std::vector<unsigned int> ssrcs;
+  EXPECT_CALL(remote_bitrate_observer, OnReceiveBitrateChanged(_, _))
+      .WillRepeatedly(SaveArg<0>(&ssrcs));
+
+  for (int i = 0; i < 10; ++i) {
+    clock_.AdvanceTimeMilliseconds((1000 * payload_size) / kInitialBitrateBps);
+    int64_t now_ms = clock_.TimeInMilliseconds();
+    header.extension.absoluteSendTime = AbsSendTime(now_ms, 1000);
+    controller_->OnReceivedPacket(now_ms, payload_size, header);
+  }
+
+  ASSERT_EQ(1u, ssrcs.size());
+  EXPECT_EQ(header.ssrc, ssrcs[0]);
+}
+
 }  // namespace test
 }  // namespace webrtc