Switch voice transport to use Call and Stream instead of VoENetwork.

webrtc/audio/audio_receive_stream_unittest.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
@@ skipping 80 matching lines @@
           EXPECT_CALL(*channel_proxy_, EnableReceiveTransportSequenceNumber(
                                            kTransportSequenceNumberId))
               .Times(1);
           EXPECT_CALL(*channel_proxy_,
                       RegisterReceiverCongestionControlObjects(&packet_router_))
               .Times(1);
           EXPECT_CALL(congestion_controller_, packet_router())
               .WillOnce(Return(&packet_router_));
           EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects())
               .Times(1);
+          EXPECT_CALL(*channel_proxy_, RegisterExternalTransport(nullptr))
+              .Times(1);
+          EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport())
+              .Times(1);
           return channel_proxy_;
         }));
     stream_config_.voe_channel_id = kChannelId;
     stream_config_.rtp.local_ssrc = kLocalSsrc;
     stream_config_.rtp.remote_ssrc = kRemoteSsrc;
     stream_config_.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeId));
     stream_config_.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kAudioLevel, kAudioLevelId));
     stream_config_.rtp.extensions.push_back(RtpExtension(
         RtpExtension::kTransportSequenceNumber, kTransportSequenceNumberId));
   }
 
   MockCongestionController* congestion_controller() {
     return &congestion_controller_;
   }
   MockRemoteBitrateEstimator* remote_bitrate_estimator() {
     return &remote_bitrate_estimator_;
   }
   AudioReceiveStream::Config& config() { return stream_config_; }
   rtc::scoped_refptr<AudioState> audio_state() { return audio_state_; }
   MockVoiceEngine& voice_engine() { return voice_engine_; }
+  MockVoEChannelProxy* channel_proxy() { return channel_proxy_; }
 
   void SetupMockForBweFeedback(bool send_side_bwe) {
     EXPECT_CALL(congestion_controller_,
                 GetRemoteBitrateEstimator(send_side_bwe))
         .WillOnce(Return(&remote_bitrate_estimator_));
     EXPECT_CALL(remote_bitrate_estimator_,
                 RemoveStream(stream_config_.rtp.remote_ssrc));
   }
 
   void SetupMockForGetStats() {
@@ skipping 41 matching lines @@
   it += 2;
   const size_t kExtensionDataLength = kOneByteExtensionLength - 1;
   uint32_t shifted_value = extension_value
                            << (8 * (kExtensionDataLength - value_length));
   *it = (id << 4) + (value_length - 1);
   ++it;
   ByteWriter<uint32_t, kExtensionDataLength>::WriteBigEndian(&(*it),
                                                              shifted_value);
 }
 
-std::vector<uint8_t> CreateRtpHeaderWithOneByteExtension(
+const std::vector<uint8_t> CreateRtpHeaderWithOneByteExtension(
     int extension_id,
     uint32_t extension_value,
     size_t value_length) {
   std::vector<uint8_t> header;
   header.resize(webrtc::kRtpHeaderSize + kOneByteExtensionHeaderLength +
                 kOneByteExtensionLength);
   header[0] = 0x80;   // Version 2.
   header[0] |= 0x10;  // Set extension bit.
   header[1] = 100;    // Payload type.
   header[1] |= 0x80;  // Marker bit is set.
   ByteWriter<uint16_t>::WriteBigEndian(&header[2], 0x1234);  // Sequence number.
   ByteWriter<uint32_t>::WriteBigEndian(&header[4], 0x5678);  // Timestamp.
   ByteWriter<uint32_t>::WriteBigEndian(&header[8], 0x4321);  // SSRC.
 
   BuildOneByteExtension(header.begin() + webrtc::kRtpHeaderSize, extension_id,
                         extension_value, value_length);
   return header;
 }
+
+const std::vector<uint8_t> CreateRtcpSenderReport() {
+  std::vector<uint8_t> packet;
+  const size_t kRtcpSrLength = 28;  // In bytes.
+  packet.resize(kRtcpSrLength);
+  packet[0] = 0x80;  // Version 2.
+  packet[1] = 0xc8;  // PT = 200, SR.
+  // Length in number of 32-bit words - 1.
+  ByteWriter<uint16_t>::WriteBigEndian(&packet[2], 6);
+  ByteWriter<uint32_t>::WriteBigEndian(&packet[4], kLocalSsrc);
+  return packet;
+}
 }  // namespace
 
 TEST(AudioReceiveStreamTest, ConfigToString) {
   AudioReceiveStream::Config config;
   config.rtp.remote_ssrc = kRemoteSsrc;
   config.rtp.local_ssrc = kLocalSsrc;
   config.rtp.extensions.push_back(
       RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeId));
   config.voe_channel_id = kChannelId;
   EXPECT_EQ(
       "{rtp: {remote_ssrc: 1234, local_ssrc: 5678, extensions: [{name: "
       "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time, id: 2}], "
       "transport_cc: off}, "
-      "receive_transport: nullptr, rtcp_send_transport: nullptr, "
+      "rtcp_send_transport: nullptr, "
       "voe_channel_id: 2}",
       config.ToString());
 }
 
 TEST(AudioReceiveStreamTest, ConstructDestruct) {
   ConfigHelper helper;
   internal::AudioReceiveStream recv_stream(
       helper.congestion_controller(), helper.config(), helper.audio_state());
 }
 
 MATCHER_P(VerifyHeaderExtension, expected_extension, "") {
   return arg.extension.hasAbsoluteSendTime ==
              expected_extension.hasAbsoluteSendTime &&
          arg.extension.absoluteSendTime ==
              expected_extension.absoluteSendTime &&
          arg.extension.hasTransportSequenceNumber ==
              expected_extension.hasTransportSequenceNumber &&
          arg.extension.transportSequenceNumber ==
              expected_extension.transportSequenceNumber;
 }
 
-TEST(AudioReceiveStreamTest, AudioPacketUpdatesBweFeedback) {
+TEST(AudioReceiveStreamTest, ReceiveRtpPacket) {
   ConfigHelper helper;
   helper.config().rtp.transport_cc = true;
   helper.SetupMockForBweFeedback(true);
   internal::AudioReceiveStream recv_stream(
       helper.congestion_controller(), helper.config(), helper.audio_state());
   const int kTransportSequenceNumberValue = 1234;
   std::vector<uint8_t> rtp_packet = CreateRtpHeaderWithOneByteExtension(
       kTransportSequenceNumberId, kTransportSequenceNumberValue, 2);
   PacketTime packet_time(5678000, 0);
   const size_t kExpectedHeaderLength = 20;
   RTPHeaderExtension expected_extension;
   expected_extension.hasTransportSequenceNumber = true;
   expected_extension.transportSequenceNumber = kTransportSequenceNumberValue;
   EXPECT_CALL(*helper.remote_bitrate_estimator(),
               IncomingPacket(packet_time.timestamp / 1000,
                              rtp_packet.size() - kExpectedHeaderLength,
                              VerifyHeaderExtension(expected_extension), false))
       .Times(1);
+  EXPECT_CALL(*helper.channel_proxy(),
+              ReceivedRTPPacket(&rtp_packet[0],
+                                rtp_packet.size(),
+                                _))
+      .WillOnce(Return(true));
   EXPECT_TRUE(
       recv_stream.DeliverRtp(&rtp_packet[0], rtp_packet.size(), packet_time));
 }
 
+TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) {
+  ConfigHelper helper;
+  helper.config().rtp.transport_cc = true;
+  helper.SetupMockForBweFeedback(true);
+  internal::AudioReceiveStream recv_stream(
+      helper.congestion_controller(), helper.config(), helper.audio_state());
+
+  std::vector<uint8_t> rtcp_packet = CreateRtcpSenderReport();
+  EXPECT_CALL(*helper.channel_proxy(),
+              ReceivedRTCPPacket(&rtcp_packet[0], rtcp_packet.size()))
+      .WillOnce(Return(true));
+  EXPECT_TRUE(recv_stream.DeliverRtcp(&rtcp_packet[0], rtcp_packet.size()));
+}
+
+
 TEST(AudioReceiveStreamTest, GetStats) {
   ConfigHelper helper;
   internal::AudioReceiveStream recv_stream(
       helper.congestion_controller(), helper.config(), helper.audio_state());
   helper.SetupMockForGetStats();
   AudioReceiveStream::Stats stats = recv_stream.GetStats();
   EXPECT_EQ(kRemoteSsrc, stats.remote_ssrc);
   EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesReceived), stats.bytes_rcvd);
   EXPECT_EQ(static_cast<uint32_t>(kCallStats.packetsReceived),
             stats.packets_rcvd);
@@ skipping 23 matching lines @@
   EXPECT_EQ(kAudioDecodeStats.calls_to_neteq, stats.decoding_calls_to_neteq);
   EXPECT_EQ(kAudioDecodeStats.decoded_normal, stats.decoding_normal);
   EXPECT_EQ(kAudioDecodeStats.decoded_plc, stats.decoding_plc);
   EXPECT_EQ(kAudioDecodeStats.decoded_cng, stats.decoding_cng);
   EXPECT_EQ(kAudioDecodeStats.decoded_plc_cng, stats.decoding_plc_cng);
   EXPECT_EQ(kCallStats.capture_start_ntp_time_ms_,
             stats.capture_start_ntp_time_ms);
 }
 }  // namespace test
 }  // namespace webrtc