Revert of Remove audio/video distinction for probe packets. (patchset #2 id:20001 of https://codereview.webrtc.org/2061193002/ )

Reason for revert:
Revert this because it broke the google3 import build.
http://webrtc-buildbot-master.mtv.corp.google.com:21000/builders/WebRTC%20google3%20Importer%20%28Shem%20TOT%29/builds/67/steps/blaze_regular_tests/logs/stdio

Original issue's description:
> Remove audio/video distinction for probe packets.
>
> Allows detecting large-enough audio packets as part of a probe,
> speculative fix for a rampup-time regression in M50. These packets are
> accounted on the send side when probing.
>
> BUG=webrtc:5985
> R=mflodman@webrtc.org, philipel@webrtc.org
>
> Committed: https://crrev.com/a7d88d38448f6a5677a017562765ab505b89d468
> Cr-Commit-Position: refs/heads/master@{#13210}

TBR=mflodman@webrtc.org,philipel@webrtc.org,pbos@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:5985

Review-Url: https://codereview.webrtc.org/2086633002
Cr-Commit-Position: refs/heads/master@{#13221}

Author: honghaiz

webrtc/audio/audio_receive_stream.cc

@@ -254,7 +254,7 @@ bool AudioReceiveStream::DeliverRtp(const uint8_t* packet,
       arrival_time_ms = (packet_time.timestamp + 500) / 1000;
     size_t payload_size = length - header.headerLength;
     remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
-                                              header);
+                                              header, false);
   }
 
   return channel_proxy_->ReceivedRTPPacket(packet, length, packet_time);

webrtc/audio/audio_receive_stream_unittest.cc

@@ -279,7 +279,7 @@ TEST(AudioReceiveStreamTest, ReceiveRtpPacket) {
   EXPECT_CALL(*helper.remote_bitrate_estimator(),
               IncomingPacket(packet_time.timestamp / 1000,
                              rtp_packet.size() - kExpectedHeaderLength,
-                             VerifyHeaderExtension(expected_extension)))
+                             VerifyHeaderExtension(expected_extension), false))
       .Times(1);
   EXPECT_CALL(*helper.channel_proxy(),
               ReceivedRTPPacket(&rtp_packet[0],

webrtc/modules/congestion_controller/congestion_controller.cc

@@ -48,10 +48,11 @@ class WrappingBitrateEstimator : public RemoteBitrateEstimator {
 
   void IncomingPacket(int64_t arrival_time_ms,
                       size_t payload_size,
-                      const RTPHeader& header) override {
+                      const RTPHeader& header,
+                      bool was_paced) override {
     CriticalSectionScoped cs(crit_sect_.get());
     PickEstimatorFromHeader(header);
-    rbe_->IncomingPacket(arrival_time_ms, payload_size, header);
+    rbe_->IncomingPacket(arrival_time_ms, payload_size, header, was_paced);
   }
 
   void Process() override {

webrtc/modules/congestion_controller/delay_based_bwe.cc

@@ -198,14 +198,15 @@ void DelayBasedBwe::IncomingPacketFeedbackVector(
   for (const auto& packet_info : packet_feedback_vector) {
     IncomingPacketInfo(packet_info.arrival_time_ms,
                        ConvertMsTo24Bits(packet_info.send_time_ms),
-                       packet_info.payload_size, 0,
+                       packet_info.payload_size, 0, packet_info.was_paced,
                        packet_info.probe_cluster_id);
   }
 }
 
 void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
                                    size_t payload_size,
-                                   const RTPHeader& header) {
+                                   const RTPHeader& header,
+                                   bool was_paced) {
   RTC_DCHECK(network_thread_.CalledOnValidThread());
   if (!header.extension.hasAbsoluteSendTime) {
     // NOTE! The BitrateEstimatorTest relies on this EXACT log line.
@@ -214,12 +215,14 @@ void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
     return;
   }
   IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
-                     payload_size, header.ssrc, PacketInfo::kNotAProbe);
+                     payload_size, header.ssrc, was_paced,
+                     PacketInfo::kNotAProbe);
 }
 
 void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
                                    size_t payload_size,
                                    const RTPHeader& header,
+                                   bool was_paced,
                                    int probe_cluster_id) {
   RTC_DCHECK(network_thread_.CalledOnValidThread());
   if (!header.extension.hasAbsoluteSendTime) {
@@ -229,13 +232,14 @@ void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
     return;
   }
   IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
-                     payload_size, header.ssrc, probe_cluster_id);
+                     payload_size, header.ssrc, was_paced, probe_cluster_id);
 }
 
 void DelayBasedBwe::IncomingPacketInfo(int64_t arrival_time_ms,
                                        uint32_t send_time_24bits,
                                        size_t payload_size,
                                        uint32_t ssrc,
+                                       bool was_paced,
                                        int probe_cluster_id) {
   assert(send_time_24bits < (1ul << 24));
   // Shift up send time to use the full 32 bits that inter_arrival works with,

webrtc/modules/congestion_controller/delay_based_bwe.h

@@ -40,11 +40,13 @@ class DelayBasedBwe : public RemoteBitrateEstimator {
 
   void IncomingPacket(int64_t arrival_time_ms,
                       size_t payload_size,
-                      const RTPHeader& header) override;
+                      const RTPHeader& header,
+                      bool was_paced) override;
 
   void IncomingPacket(int64_t arrival_time_ms,
                       size_t payload_size,
                       const RTPHeader& header,
+                      bool was_paced,
                       int probe_cluster_id);
 
   // This class relies on Process() being called periodically (at least once
@@ -110,6 +112,7 @@ class DelayBasedBwe : public RemoteBitrateEstimator {
                           uint32_t send_time_24bits,
                           size_t payload_size,
                           uint32_t ssrc,
+                          bool was_paced,
                           int probe_cluster_id);
 
   void ComputeClusters(std::list<Cluster>* clusters) const;

webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc

@@ -33,6 +33,7 @@ class TestDelayBasedBwe : public ::testing::Test, public RemoteBitrateObserver {
                       int64_t arrival_time,
                       uint32_t rtp_timestamp,
                       uint32_t absolute_send_time,
+                      bool was_paced,
                       int probe_cluster_id) {
     RTPHeader header;
     memset(&header, 0, sizeof(header));
@@ -41,7 +42,7 @@ class TestDelayBasedBwe : public ::testing::Test, public RemoteBitrateObserver {
     header.extension.hasAbsoluteSendTime = true;
     header.extension.absoluteSendTime = absolute_send_time;
     bwe_.IncomingPacket(arrival_time + kArrivalTimeClockOffsetMs, payload_size,
-                        header, probe_cluster_id);
+                        header, was_paced, probe_cluster_id);
   }
 
   void OnReceiveBitrateChanged(const std::vector<uint32_t>& ssrcs,
@@ -73,15 +74,17 @@ TEST_F(TestDelayBasedBwe, ProbeDetection) {
   for (int i = 0; i < kNumProbes; ++i) {
     clock_.AdvanceTimeMilliseconds(10);
     now_ms = clock_.TimeInMilliseconds();
-    IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000), 0);
+    IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
+                   true, 0);
   }
   EXPECT_TRUE(bitrate_updated());
 
   // Second burst sent at 8 * 1000 / 5 = 1600 kbps.
   for (int i = 0; i < kNumProbes; ++i) {
     clock_.AdvanceTimeMilliseconds(5);
     now_ms = clock_.TimeInMilliseconds();
-    IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000), 1);
+    IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
+                   true, 1);
   }
 
   EXPECT_TRUE(bitrate_updated());
@@ -95,11 +98,12 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionNonPacedPackets) {
   for (int i = 0; i < kNumProbes; ++i) {
     clock_.AdvanceTimeMilliseconds(5);
     now_ms = clock_.TimeInMilliseconds();
-    IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000), 0);
+    IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
+                   true, 0);
     // Non-paced packet, arriving 5 ms after.
     clock_.AdvanceTimeMilliseconds(5);
     IncomingPacket(0, PacedSender::kMinProbePacketSize + 1, now_ms, 90 * now_ms,
-                   AbsSendTime(now_ms, 1000), PacketInfo::kNotAProbe);
+                   AbsSendTime(now_ms, 1000), false, PacketInfo::kNotAProbe);
   }
 
   EXPECT_TRUE(bitrate_updated());
@@ -117,7 +121,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionTooHighBitrate) {
     now_ms = clock_.TimeInMilliseconds();
     send_time_ms += 10;
     IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
-                   AbsSendTime(send_time_ms, 1000), 0);
+                   AbsSendTime(send_time_ms, 1000), true, 0);
   }
 
   // Second burst sent at 8 * 1000 / 5 = 1600 kbps, arriving at 8 * 1000 / 8 =
@@ -127,7 +131,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionTooHighBitrate) {
     now_ms = clock_.TimeInMilliseconds();
     send_time_ms += 5;
     IncomingPacket(0, 1000, now_ms, send_time_ms,
-                   AbsSendTime(send_time_ms, 1000), 1);
+                   AbsSendTime(send_time_ms, 1000), true, 1);
   }
 
   EXPECT_TRUE(bitrate_updated());
@@ -144,7 +148,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionSlightlyFasterArrival) {
     send_time_ms += 10;
     now_ms = clock_.TimeInMilliseconds();
     IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
-                   AbsSendTime(send_time_ms, 1000), 23);
+                   AbsSendTime(send_time_ms, 1000), true, 23);
   }
 
   EXPECT_TRUE(bitrate_updated());
@@ -161,7 +165,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionFasterArrival) {
     send_time_ms += 10;
     now_ms = clock_.TimeInMilliseconds();
     IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
-                   AbsSendTime(send_time_ms, 1000), 0);
+                   AbsSendTime(send_time_ms, 1000), true, 0);
   }
 
   EXPECT_FALSE(bitrate_updated());
@@ -177,7 +181,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionSlowerArrival) {
     send_time_ms += 5;
     now_ms = clock_.TimeInMilliseconds();
     IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
-                   AbsSendTime(send_time_ms, 1000), 1);
+                   AbsSendTime(send_time_ms, 1000), true, 1);
   }
 
   EXPECT_TRUE(bitrate_updated());
@@ -194,7 +198,7 @@ TEST_F(TestDelayBasedBwe, ProbeDetectionSlowerArrivalHighBitrate) {
     send_time_ms += 1;
     now_ms = clock_.TimeInMilliseconds();
     IncomingPacket(0, 1000, now_ms, 90 * send_time_ms,
-                   AbsSendTime(send_time_ms, 1000), 1);
+                   AbsSendTime(send_time_ms, 1000), true, 1);
   }
 
   EXPECT_TRUE(bitrate_updated());
@@ -209,7 +213,7 @@ TEST_F(TestDelayBasedBwe, ProbingIgnoresSmallPackets) {
     clock_.AdvanceTimeMilliseconds(10);
     now_ms = clock_.TimeInMilliseconds();
     IncomingPacket(0, PacedSender::kMinProbePacketSize, now_ms, 90 * now_ms,
-                   AbsSendTime(now_ms, 1000), 1);
+                   AbsSendTime(now_ms, 1000), true, 1);
   }
 
   EXPECT_FALSE(bitrate_updated());
@@ -219,7 +223,8 @@ TEST_F(TestDelayBasedBwe, ProbingIgnoresSmallPackets) {
   for (int i = 0; i < kNumProbes; ++i) {
     clock_.AdvanceTimeMilliseconds(10);
     now_ms = clock_.TimeInMilliseconds();
-    IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000), 1);
+    IncomingPacket(0, 1000, now_ms, 90 * now_ms, AbsSendTime(now_ms, 1000),
+                   true, 1);
   }
 
   // Wait long enough so that we can call Process again.

webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h

@@ -28,7 +28,7 @@ class MockRemoteBitrateEstimator : public RemoteBitrateEstimator {
  public:
   MOCK_METHOD1(IncomingPacketFeedbackVector,
                void(const std::vector<PacketInfo>&));
-  MOCK_METHOD3(IncomingPacket, void(int64_t, size_t, const RTPHeader&));
+  MOCK_METHOD4(IncomingPacket, void(int64_t, size_t, const RTPHeader&, bool));
   MOCK_METHOD1(RemoveStream, void(uint32_t));
   MOCK_CONST_METHOD2(LatestEstimate, bool(std::vector<uint32_t>*, uint32_t*));
 

webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h

@@ -58,7 +58,8 @@ class RemoteBitrateEstimator : public CallStatsObserver, public Module {
   // Note that |arrival_time_ms| can be of an arbitrary time base.
   virtual void IncomingPacket(int64_t arrival_time_ms,
                               size_t payload_size,
-                              const RTPHeader& header) = 0;
+                              const RTPHeader& header,
+                              bool was_paced) = 0;
 
   // Removes all data for |ssrc|.
   virtual void RemoveStream(uint32_t ssrc) = 0;

webrtc/modules/remote_bitrate_estimator/include/send_time_history.h

@@ -26,6 +26,7 @@ class SendTimeHistory {
 
   void AddAndRemoveOld(uint16_t sequence_number,
                        size_t length,
+                       bool was_paced,
                        int probe_cluster_id);
   bool OnSentPacket(uint16_t sequence_number, int64_t timestamp);
   // Look up PacketInfo for a sent packet, based on the sequence number, and

webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc

@@ -211,29 +211,30 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketFeedbackVector(
   for (const auto& packet_info : packet_feedback_vector) {
     IncomingPacketInfo(packet_info.arrival_time_ms,
                        ConvertMsTo24Bits(packet_info.send_time_ms),
-                       packet_info.payload_size, 0);
+                       packet_info.payload_size, 0, packet_info.was_paced);
   }
 }
 
-void RemoteBitrateEstimatorAbsSendTime::IncomingPacket(
-    int64_t arrival_time_ms,
-    size_t payload_size,
-    const RTPHeader& header) {
+void RemoteBitrateEstimatorAbsSendTime::IncomingPacket(int64_t arrival_time_ms,
+                                                       size_t payload_size,
+                                                       const RTPHeader& header,
+                                                       bool was_paced) {
   RTC_DCHECK(network_thread_.CalledOnValidThread());
   if (!header.extension.hasAbsoluteSendTime) {
     LOG(LS_WARNING) << "RemoteBitrateEstimatorAbsSendTimeImpl: Incoming packet "
                        "is missing absolute send time extension!";
     return;
   }
   IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
-                     payload_size, header.ssrc);
+                     payload_size, header.ssrc, was_paced);
 }
 
 void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
     int64_t arrival_time_ms,
     uint32_t send_time_24bits,
     size_t payload_size,
-    uint32_t ssrc) {
+    uint32_t ssrc,
+    bool was_paced) {
   assert(send_time_24bits < (1ul << 24));
   // Shift up send time to use the full 32 bits that inter_arrival works with,
   // so wrapping works properly.
@@ -263,6 +264,10 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
   uint32_t ts_delta = 0;
   int64_t t_delta = 0;
   int size_delta = 0;
+  // For now only try to detect probes while we don't have a valid estimate, and
+  // make sure the packet was paced. We currently assume that only packets
+  // larger than 200 bytes are paced by the sender.
+  was_paced = was_paced && payload_size > PacedSender::kMinProbePacketSize;
   bool update_estimate = false;
   uint32_t target_bitrate_bps = 0;
   std::vector<uint32_t> ssrcs;
@@ -274,10 +279,7 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
     RTC_DCHECK(estimator_.get());
     ssrcs_[ssrc] = now_ms;
 
-    // For now only try to detect probes while we don't have a valid estimate.
-    // We currently assume that only packets larger than 200 bytes are paced by
-    // the sender.
-    if (payload_size > PacedSender::kMinProbePacketSize &&
+    if (was_paced &&
         (!remote_rate_.ValidEstimate() ||
          now_ms - first_packet_time_ms_ < kInitialProbingIntervalMs)) {
       // TODO(holmer): Use a map instead to get correct order?