Implement AudioSendStream::GetStats().

talk/media/webrtc/webrtcvoiceengine_unittest.cc

 /*
  * libjingle
  * Copyright 2008 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 39 matching lines @@
 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1, 0);
 const cricket::AudioCodec kRedCodec(117, "red", 8000, 0, 1, 0);
 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1, 0);
 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1, 0);
 const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000, 0,
                                                1, 0);
 const cricket::AudioCodec* const kAudioCodecs[] = {
     &kPcmuCodec, &kIsacCodec, &kOpusCodec, &kG722CodecVoE, &kRedCodec,
     &kCn8000Codec, &kCn16000Codec, &kTelephoneEventCodec,
 };
-static uint32_t kSsrc1 = 0x99;
-static uint32_t kSsrc2 = 0x98;
-static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
+const uint32_t kSsrc1 = 0x99;
+const uint32_t kSsrc2 = 0x98;
+const uint32_t kSsrcs4[] = { 1, 2, 3, 4 };
 
 class FakeVoEWrapper : public cricket::VoEWrapper {
  public:
   explicit FakeVoEWrapper(cricket::FakeWebRtcVoiceEngine* engine)
       : cricket::VoEWrapper(engine,  // processing
                             engine,  // base
                             engine,  // codec
                             engine,  // dtmf
                             engine,  // hw
                             engine,  // network
@@ skipping 44 matching lines @@
     if (!SetupEngine()) {
       return false;
     }
     return channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrc1));
   }
   void SetupForMultiSendStream() {
     EXPECT_TRUE(SetupEngineWithSendStream());
     // Remove stream added in Setup.
     int default_channel_num = voe_.GetLastChannel();
-    uint32_t default_send_ssrc = 0u;
-    EXPECT_EQ(0, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc));
-    EXPECT_EQ(kSsrc1, default_send_ssrc);
-    EXPECT_TRUE(channel_->RemoveSendStream(default_send_ssrc));
+    EXPECT_EQ(kSsrc1, voe_.GetLocalSSRC(default_channel_num));
+    EXPECT_TRUE(channel_->RemoveSendStream(kSsrc1));
 
     // Verify the channel does not exist.
-    EXPECT_EQ(-1, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc));
+    EXPECT_EQ(-1, voe_.GetChannelFromLocalSsrc(kSsrc1));
   }
   void DeliverPacket(const void* data, int len) {
     rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len);
     channel_->OnPacketReceived(&packet, rtc::PacketTime());
   }
   void TearDown() override {
     delete channel_;
     engine_.Terminate();
   }
 
@@ skipping 139 matching lines @@
     EXPECT_NE(channel_num, new_channel_num);
     EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(new_channel_num, ext));
 
     // Ensure all extensions go back off with an empty list.
     parameters.extensions.clear();
     EXPECT_TRUE(channel_->SetRecvParameters(parameters));
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(new_channel_num, ext));
   }
 
-  const webrtc::AudioReceiveStream::Stats& GetAudioReceiveStreamStats() const {
-    static webrtc::AudioReceiveStream::Stats stats;
-    if (stats.remote_ssrc == 0) {
-      stats.remote_ssrc = 123;
-      stats.bytes_rcvd = 456;
-      stats.packets_rcvd = 768;
-      stats.packets_lost = 101;
-      stats.fraction_lost = 23.45f;
-      stats.codec_name = "codec_name";
-      stats.ext_seqnum = 678;
-      stats.jitter_ms = 901;
-      stats.jitter_buffer_ms = 234;
-      stats.jitter_buffer_preferred_ms = 567;
-      stats.delay_estimate_ms = 890;
-      stats.audio_level = 1234;
-      stats.expand_rate = 5.67f;
-      stats.speech_expand_rate = 8.90f;
-      stats.secondary_decoded_rate = 1.23f;
-      stats.accelerate_rate = 4.56f;
-      stats.preemptive_expand_rate = 7.89f;
-      stats.decoding_calls_to_silence_generator = 012;
-      stats.decoding_calls_to_neteq = 345;
-      stats.decoding_normal = 67890;
-      stats.decoding_plc = 1234;
-      stats.decoding_cng = 5678;
-      stats.decoding_plc_cng = 9012;
-      stats.capture_start_ntp_time_ms = 3456;
+  webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const {
+    webrtc::AudioSendStream::Stats stats;
+    stats.local_ssrc = 12;
+    stats.bytes_sent = 345;
+    stats.packets_sent = 678;
+    stats.packets_lost = 9012;
+    stats.fraction_lost = 34.56f;
+    stats.codec_name = "codec_name_send";
+    stats.ext_seqnum = 789;
+    stats.jitter_ms = 12;
+    stats.rtt_ms = 345;
+    stats.audio_level = 678;
+    stats.aec_quality_min = 9.01f;
+    stats.echo_delay_median_ms = 234;
+    stats.echo_delay_std_ms = 567;
+    stats.echo_return_loss = 890;
+    stats.echo_return_loss_enhancement = 1234;
+    stats.typing_noise_detected = true;
+    return stats;
+  }
+  void SetAudioSendStreamStats() {
+    for (auto* s : call_.GetAudioSendStreams()) {
+      s->SetStats(GetAudioSendStreamStats());
     }
+  }
+  void VerifyVoiceSenderInfo(const cricket::VoiceSenderInfo& info) {
+    const auto stats = GetAudioSendStreamStats();
+    EXPECT_EQ(info.ssrc(), stats.local_ssrc);
+    EXPECT_EQ(info.bytes_sent, stats.bytes_sent);
+    EXPECT_EQ(info.packets_sent, stats.packets_sent);
+    EXPECT_EQ(info.packets_lost, stats.packets_lost);
+    EXPECT_EQ(info.fraction_lost, stats.fraction_lost);
+    EXPECT_EQ(info.codec_name, stats.codec_name);
+    EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum);
+    EXPECT_EQ(info.jitter_ms, stats.jitter_ms);
+    EXPECT_EQ(info.rtt_ms, stats.rtt_ms);
+    EXPECT_EQ(info.audio_level, stats.audio_level);
+    EXPECT_EQ(info.aec_quality_min, stats.aec_quality_min);
+    EXPECT_EQ(info.echo_delay_median_ms, stats.echo_delay_median_ms);
+    EXPECT_EQ(info.echo_delay_std_ms, stats.echo_delay_std_ms);
+    EXPECT_EQ(info.echo_return_loss, stats.echo_return_loss);
+    EXPECT_EQ(info.echo_return_loss_enhancement,
+              stats.echo_return_loss_enhancement);
+    // TODO(solenberg): Move typing noise detection into AudioSendStream.
+    // EXPECT_EQ(info.typing_noise_detected, stats.typing_noise_detected);
+  }
+
+  webrtc::AudioReceiveStream::Stats GetAudioReceiveStreamStats() const {
+    webrtc::AudioReceiveStream::Stats stats;
+    stats.remote_ssrc = 123;
+    stats.bytes_rcvd = 456;
+    stats.packets_rcvd = 768;
+    stats.packets_lost = 101;
+    stats.fraction_lost = 23.45f;
+    stats.codec_name = "codec_name_recv";
+    stats.ext_seqnum = 678;
+    stats.jitter_ms = 901;
+    stats.jitter_buffer_ms = 234;
+    stats.jitter_buffer_preferred_ms = 567;
+    stats.delay_estimate_ms = 890;
+    stats.audio_level = 1234;
+    stats.expand_rate = 5.67f;
+    stats.speech_expand_rate = 8.90f;
+    stats.secondary_decoded_rate = 1.23f;
+    stats.accelerate_rate = 4.56f;
+    stats.preemptive_expand_rate = 7.89f;
+    stats.decoding_calls_to_silence_generator = 12;
+    stats.decoding_calls_to_neteq = 345;
+    stats.decoding_normal = 67890;
+    stats.decoding_plc = 1234;
+    stats.decoding_cng = 5678;
+    stats.decoding_plc_cng = 9012;
+    stats.capture_start_ntp_time_ms = 3456;
     return stats;
   }
   void SetAudioReceiveStreamStats() {
     for (auto* s : call_.GetAudioReceiveStreams()) {
       s->SetStats(GetAudioReceiveStreamStats());
     }
   }
   void VerifyVoiceReceiverInfo(const cricket::VoiceReceiverInfo& info) {
-    const auto& kStats = GetAudioReceiveStreamStats();
-    EXPECT_EQ(info.local_stats.front().ssrc, kStats.remote_ssrc);
-    EXPECT_EQ(info.bytes_rcvd, kStats.bytes_rcvd);
-    EXPECT_EQ(info.packets_rcvd, kStats.packets_rcvd);
-    EXPECT_EQ(info.packets_lost, kStats.packets_lost);
-    EXPECT_EQ(info.fraction_lost, kStats.fraction_lost);
-    EXPECT_EQ(info.codec_name, kStats.codec_name);
-    EXPECT_EQ(info.ext_seqnum, kStats.ext_seqnum);
-    EXPECT_EQ(info.jitter_ms, kStats.jitter_ms);
-    EXPECT_EQ(info.jitter_buffer_ms, kStats.jitter_buffer_ms);
+    const auto stats = GetAudioReceiveStreamStats();
+    EXPECT_EQ(info.ssrc(), stats.remote_ssrc);
+    EXPECT_EQ(info.bytes_rcvd, stats.bytes_rcvd);
+    EXPECT_EQ(info.packets_rcvd, stats.packets_rcvd);
+    EXPECT_EQ(info.packets_lost, stats.packets_lost);
+    EXPECT_EQ(info.fraction_lost, stats.fraction_lost);
+    EXPECT_EQ(info.codec_name, stats.codec_name);
+    EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum);
+    EXPECT_EQ(info.jitter_ms, stats.jitter_ms);
+    EXPECT_EQ(info.jitter_buffer_ms, stats.jitter_buffer_ms);
     EXPECT_EQ(info.jitter_buffer_preferred_ms,
-              kStats.jitter_buffer_preferred_ms);
-    EXPECT_EQ(info.delay_estimate_ms, kStats.delay_estimate_ms);
-    EXPECT_EQ(info.audio_level, kStats.audio_level);
-    EXPECT_EQ(info.expand_rate, kStats.expand_rate);
-    EXPECT_EQ(info.speech_expand_rate, kStats.speech_expand_rate);
-    EXPECT_EQ(info.secondary_decoded_rate, kStats.secondary_decoded_rate);
-    EXPECT_EQ(info.accelerate_rate, kStats.accelerate_rate);
-    EXPECT_EQ(info.preemptive_expand_rate, kStats.preemptive_expand_rate);
+              stats.jitter_buffer_preferred_ms);
+    EXPECT_EQ(info.delay_estimate_ms, stats.delay_estimate_ms);
+    EXPECT_EQ(info.audio_level, stats.audio_level);
+    EXPECT_EQ(info.expand_rate, stats.expand_rate);
+    EXPECT_EQ(info.speech_expand_rate, stats.speech_expand_rate);
+    EXPECT_EQ(info.secondary_decoded_rate, stats.secondary_decoded_rate);
+    EXPECT_EQ(info.accelerate_rate, stats.accelerate_rate);
+    EXPECT_EQ(info.preemptive_expand_rate, stats.preemptive_expand_rate);
     EXPECT_EQ(info.decoding_calls_to_silence_generator,
-              kStats.decoding_calls_to_silence_generator);
-    EXPECT_EQ(info.decoding_calls_to_neteq, kStats.decoding_calls_to_neteq);
-    EXPECT_EQ(info.decoding_normal, kStats.decoding_normal);
-    EXPECT_EQ(info.decoding_plc, kStats.decoding_plc);
-    EXPECT_EQ(info.decoding_cng, kStats.decoding_cng);
-    EXPECT_EQ(info.decoding_plc_cng, kStats.decoding_plc_cng);
-    EXPECT_EQ(info.capture_start_ntp_time_ms, kStats.capture_start_ntp_time_ms);
+              stats.decoding_calls_to_silence_generator);
+    EXPECT_EQ(info.decoding_calls_to_neteq, stats.decoding_calls_to_neteq);
+    EXPECT_EQ(info.decoding_normal, stats.decoding_normal);
+    EXPECT_EQ(info.decoding_plc, stats.decoding_plc);
+    EXPECT_EQ(info.decoding_cng, stats.decoding_cng);
+    EXPECT_EQ(info.decoding_plc_cng, stats.decoding_plc_cng);
+    EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms);
   }
 
  protected:
   cricket::FakeCall call_;
   cricket::FakeWebRtcVoiceEngine voe_;
   FakeVoETraceWrapper* trace_wrapper_;
   cricket::WebRtcVoiceEngine engine_;
   cricket::VoiceMediaChannel* channel_;
 
   cricket::AudioSendParameters send_parameters_;
@@ skipping 1655 matching lines @@
 
 // Test we can set the correct statistics on all send streams.
 TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) {
   SetupForMultiSendStream();
 
   // Create send streams.
   for (uint32_t ssrc : kSsrcs4) {
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(ssrc)));
   }
+  SetAudioSendStreamStats();
+
   // Create a receive stream to check that none of the send streams end up in
   // the receive stream stats.
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
   // We need send codec to be set to get all stats.
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
-  cricket::VoiceMediaInfo info;
-  EXPECT_EQ(true, channel_->GetStats(&info));
-  EXPECT_EQ(static_cast<size_t>(ARRAY_SIZE(kSsrcs4)), info.senders.size());
+  // Check stats for the added streams.
+  {
+    cricket::VoiceMediaInfo info;
+    EXPECT_EQ(true, channel_->GetStats(&info));
 
-  // Verify the statistic information is correct.
-  // TODO(solenberg): Make this loop ordering independent.
-  for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
-    EXPECT_EQ(kSsrcs4[i], info.senders[i].ssrc());
-    EXPECT_EQ(kPcmuCodec.name, info.senders[i].codec_name);
-    EXPECT_EQ(cricket::kIntStatValue, info.senders[i].bytes_sent);
-    EXPECT_EQ(cricket::kIntStatValue, info.senders[i].packets_sent);
-    EXPECT_EQ(cricket::kIntStatValue, info.senders[i].packets_lost);
-    EXPECT_EQ(cricket::kFractionLostStatValue, info.senders[i].fraction_lost);
-    EXPECT_EQ(cricket::kIntStatValue, info.senders[i].ext_seqnum);
-    EXPECT_EQ(cricket::kIntStatValue, info.senders[i].rtt_ms);
-    EXPECT_EQ(cricket::kIntStatValue, info.senders[i].jitter_ms);
-    EXPECT_EQ(kPcmuCodec.name, info.senders[i].codec_name);
+    // We have added 4 send streams. We should see empty stats for all.
+    EXPECT_EQ(static_cast<size_t>(ARRAY_SIZE(kSsrcs4)), info.senders.size());
+    for (const auto& sender : info.senders) {
+      VerifyVoiceSenderInfo(sender);
+    }
+
+    // We have added one receive stream. We should see empty stats.
+    EXPECT_EQ(info.receivers.size(), 1u);
+    EXPECT_EQ(info.receivers[0].ssrc(), 0);
   }
 
-  // We have added one receive stream. We should see empty stats.
-  EXPECT_EQ(info.receivers.size(), 1u);
-  EXPECT_EQ(info.receivers[0].local_stats.front().ssrc, 0);
-
   // Remove the kSsrc2 stream. No receiver stats.
-  EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
-  EXPECT_EQ(true, channel_->GetStats(&info));
-  EXPECT_EQ(0u, info.receivers.size());
+  {
+    cricket::VoiceMediaInfo info;
+    EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
+    EXPECT_EQ(true, channel_->GetStats(&info));
+    EXPECT_EQ(static_cast<size_t>(ARRAY_SIZE(kSsrcs4)), info.senders.size());
+    EXPECT_EQ(0u, info.receivers.size());
+  }
 
   // Deliver a new packet - a default receive stream should be created and we
   // should see stats again.
-  DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  SetAudioReceiveStreamStats();
-  EXPECT_EQ(true, channel_->GetStats(&info));
-  EXPECT_EQ(1u, info.receivers.size());
-  VerifyVoiceReceiverInfo(info.receivers[0]);
+  {
+    cricket::VoiceMediaInfo info;
+    DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
+    SetAudioReceiveStreamStats();
+    EXPECT_EQ(true, channel_->GetStats(&info));
+    EXPECT_EQ(static_cast<size_t>(ARRAY_SIZE(kSsrcs4)), info.senders.size());
+    EXPECT_EQ(1u, info.receivers.size());
+    VerifyVoiceReceiverInfo(info.receivers[0]);
+  }
 }
 
 // Test that we can add and remove receive streams, and do proper send/playout.
 // We can receive on multiple streams while sending one stream.
 TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
   EXPECT_TRUE(SetupEngineWithSendStream());
   int channel_num1 = voe_.GetLastChannel();
 
   // Start playout without a receive stream.
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
@@ skipping 201 matching lines @@
       "tracefilter " + rtc::ToString(webrtc::kTraceDefault);
   engine_.SetLogging(rtc::LS_VERBOSE, filter.c_str());
   EXPECT_EQ(static_cast<unsigned int>(webrtc::kTraceDefault),
             trace_wrapper_->filter_);
 }
 
 // Test that we can set the outgoing SSRC properly.
 // SSRC is set in SetupEngine by calling AddSendStream.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) {
   EXPECT_TRUE(SetupEngineWithSendStream());
-  int channel_num = voe_.GetLastChannel();
-  unsigned int send_ssrc;
-  EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc));
-  EXPECT_NE(0U, send_ssrc);
-  EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc));
-  EXPECT_EQ(kSsrc1, send_ssrc);
+  EXPECT_EQ(kSsrc1, voe_.GetLocalSSRC(voe_.GetLastChannel()));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, GetStats) {
   // Setup. We need send codec to be set to get all stats.
   EXPECT_TRUE(SetupEngineWithSendStream());
+  SetAudioSendStreamStats();
   // SetupEngineWithSendStream adds a send stream with kSsrc1, so the receive
   // stream has to use a different SSRC.
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
-  cricket::VoiceMediaInfo info;
-  EXPECT_EQ(true, channel_->GetStats(&info));
-  EXPECT_EQ(1u, info.senders.size());
-  EXPECT_EQ(kSsrc1, info.senders[0].ssrc());
-  EXPECT_EQ(kPcmuCodec.name, info.senders[0].codec_name);
-  EXPECT_EQ(cricket::kIntStatValue, info.senders[0].bytes_sent);
-  EXPECT_EQ(cricket::kIntStatValue, info.senders[0].packets_sent);
-  EXPECT_EQ(cricket::kIntStatValue, info.senders[0].packets_lost);
-  EXPECT_EQ(cricket::kFractionLostStatValue, info.senders[0].fraction_lost);
-  EXPECT_EQ(cricket::kIntStatValue, info.senders[0].ext_seqnum);
-  EXPECT_EQ(cricket::kIntStatValue, info.senders[0].rtt_ms);
-  EXPECT_EQ(cricket::kIntStatValue, info.senders[0].jitter_ms);
-  EXPECT_EQ(kPcmuCodec.name, info.senders[0].codec_name);
-  // TODO(sriniv): Add testing for more fields. These are not populated
-  // in FakeWebrtcVoiceEngine yet.
-  // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].audio_level);
-  // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_delay_median_ms);
-  // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_delay_std_ms);
-  // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_return_loss);
-  // EXPECT_EQ(cricket::kIntStatValue,
-  //           info.senders[0].echo_return_loss_enhancement);
-  // We have added one receive stream. We should see empty stats.
-  EXPECT_EQ(info.receivers.size(), 1u);
-  EXPECT_EQ(info.receivers[0].local_stats.front().ssrc, 0);
+  // Check stats for the added streams.
+  {
+    cricket::VoiceMediaInfo info;
+    EXPECT_EQ(true, channel_->GetStats(&info));
+
+    // We have added one send stream. We should see the stats we've set.
+    EXPECT_EQ(1u, info.senders.size());
+    VerifyVoiceSenderInfo(info.senders[0]);
+    // We have added one receive stream. We should see empty stats.
+    EXPECT_EQ(info.receivers.size(), 1u);
+    EXPECT_EQ(info.receivers[0].ssrc(), 0);
+  }
 
   // Remove the kSsrc2 stream. No receiver stats.
-  EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
-  EXPECT_EQ(true, channel_->GetStats(&info));
-  EXPECT_EQ(0u, info.receivers.size());
+  {
+    cricket::VoiceMediaInfo info;
+    EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
+    EXPECT_EQ(true, channel_->GetStats(&info));
+    EXPECT_EQ(1u, info.senders.size());
+    EXPECT_EQ(0u, info.receivers.size());
+  }
 
   // Deliver a new packet - a default receive stream should be created and we
   // should see stats again.
-  DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  SetAudioReceiveStreamStats();
-  EXPECT_EQ(true, channel_->GetStats(&info));
-  EXPECT_EQ(1u, info.receivers.size());
-  VerifyVoiceReceiverInfo(info.receivers[0]);
+  {
+    cricket::VoiceMediaInfo info;
+    DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
+    SetAudioReceiveStreamStats();
+    EXPECT_EQ(true, channel_->GetStats(&info));
+    EXPECT_EQ(1u, info.senders.size());
+    EXPECT_EQ(1u, info.receivers.size());
+    VerifyVoiceReceiverInfo(info.receivers[0]);
+  }
 }
 
 // Test that we can set the outgoing SSRC properly with multiple streams.
 // SSRC is set in SetupEngine by calling AddSendStream.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
   EXPECT_TRUE(SetupEngineWithSendStream());
-  int channel_num1 = voe_.GetLastChannel();
-  unsigned int send_ssrc;
-  EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num1, send_ssrc));
-  EXPECT_EQ(kSsrc1, send_ssrc);
-
+  EXPECT_EQ(kSsrc1, voe_.GetLocalSSRC(voe_.GetLastChannel()));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
-  int channel_num2 = voe_.GetLastChannel();
-  EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num2, send_ssrc));
-  EXPECT_EQ(kSsrc1, send_ssrc);
+  EXPECT_EQ(kSsrc1, voe_.GetLocalSSRC(voe_.GetLastChannel()));
 }
 
 // Test that the local SSRC is the same on sending and receiving channels if the
 // receive channel is created before the send channel.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
 
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int receive_channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(1234)));
   int send_channel_num = voe_.GetLastChannel();
 
-  unsigned int ssrc = 0;
-  EXPECT_EQ(0, voe_.GetLocalSSRC(send_channel_num, ssrc));
-  EXPECT_EQ(1234U, ssrc);
-  ssrc = 0;
-  EXPECT_EQ(0, voe_.GetLocalSSRC(receive_channel_num, ssrc));
-  EXPECT_EQ(1234U, ssrc);
+  EXPECT_EQ(1234U, voe_.GetLocalSSRC(send_channel_num));
+  EXPECT_EQ(1234U, voe_.GetLocalSSRC(receive_channel_num));
 }
 
 // Test that we can properly receive packets.
 TEST_F(WebRtcVoiceEngineTestFake, Recv) {
   EXPECT_TRUE(SetupEngine());
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
   int channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame,
                                sizeof(kPcmuFrame)));
 }
@@ skipping 143 matching lines @@
   voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1);
   EXPECT_TRUE(channel_->SetPlayout(false));
   EXPECT_FALSE(channel_->SetPlayout(true));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
   EXPECT_TRUE(SetupEngineWithSendStream());
 
   bool ec_enabled;
   webrtc::EcModes ec_mode;
-  bool ec_metrics_enabled;
   webrtc::AecmModes aecm_mode;
   bool cng_enabled;
   bool agc_enabled;
   webrtc::AgcModes agc_mode;
   webrtc::AgcConfig agc_config;
   bool ns_enabled;
   webrtc::NsModes ns_mode;
   bool highpass_filter_enabled;
   bool stereo_swapping_enabled;
   bool typing_detection_enabled;
   voe_.GetEcStatus(ec_enabled, ec_mode);
-  voe_.GetEcMetricsStatus(ec_metrics_enabled);
   voe_.GetAecmMode(aecm_mode, cng_enabled);
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetAgcConfig(agc_config);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
   stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
   voe_.GetTypingDetectionStatus(typing_detection_enabled);
   EXPECT_TRUE(ec_enabled);
-  EXPECT_TRUE(ec_metrics_enabled);
+  EXPECT_TRUE(voe_.ec_metrics_enabled());
   EXPECT_FALSE(cng_enabled);
   EXPECT_TRUE(agc_enabled);
   EXPECT_EQ(0, agc_config.targetLeveldBOv);
   EXPECT_TRUE(ns_enabled);
   EXPECT_TRUE(highpass_filter_enabled);
   EXPECT_FALSE(stereo_swapping_enabled);
   EXPECT_TRUE(typing_detection_enabled);
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
   EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
 
   // Nothing set, so all ignored.
   cricket::AudioOptions options;
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
-  voe_.GetEcMetricsStatus(ec_metrics_enabled);
   voe_.GetAecmMode(aecm_mode, cng_enabled);
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetAgcConfig(agc_config);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
   stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
   voe_.GetTypingDetectionStatus(typing_detection_enabled);
   EXPECT_TRUE(ec_enabled);
-  EXPECT_TRUE(ec_metrics_enabled);
+  EXPECT_TRUE(voe_.ec_metrics_enabled());
   EXPECT_FALSE(cng_enabled);
   EXPECT_TRUE(agc_enabled);
   EXPECT_EQ(0, agc_config.targetLeveldBOv);
   EXPECT_TRUE(ns_enabled);
   EXPECT_TRUE(highpass_filter_enabled);
   EXPECT_FALSE(stereo_swapping_enabled);
   EXPECT_TRUE(typing_detection_enabled);
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
   EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
   EXPECT_EQ(50, voe_.GetNetEqCapacity());  // From GetDefaultEngineOptions().
   EXPECT_FALSE(
       voe_.GetNetEqFastAccelerate());  // From GetDefaultEngineOptions().
 
   // Turn echo cancellation off
   options.echo_cancellation.Set(false);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
   EXPECT_FALSE(ec_enabled);
 
   // Turn echo cancellation back on, with settings, and make sure
   // nothing else changed.
   options.echo_cancellation.Set(true);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
-  voe_.GetEcMetricsStatus(ec_metrics_enabled);
   voe_.GetAecmMode(aecm_mode, cng_enabled);
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetAgcConfig(agc_config);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
   stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
   voe_.GetTypingDetectionStatus(typing_detection_enabled);
   EXPECT_TRUE(ec_enabled);
-  EXPECT_TRUE(ec_metrics_enabled);
+  EXPECT_TRUE(voe_.ec_metrics_enabled());
   EXPECT_TRUE(agc_enabled);
   EXPECT_EQ(0, agc_config.targetLeveldBOv);
   EXPECT_TRUE(ns_enabled);
   EXPECT_TRUE(highpass_filter_enabled);
   EXPECT_FALSE(stereo_swapping_enabled);
   EXPECT_TRUE(typing_detection_enabled);
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
   EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
 
   // Turn on delay agnostic aec and make sure nothing change w.r.t. echo
   // control.
   options.delay_agnostic_aec.Set(true);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
-  voe_.GetEcMetricsStatus(ec_metrics_enabled);
   voe_.GetAecmMode(aecm_mode, cng_enabled);
   EXPECT_TRUE(ec_enabled);
-  EXPECT_TRUE(ec_metrics_enabled);
+  EXPECT_TRUE(voe_.ec_metrics_enabled());
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
 
   // Turn off echo cancellation and delay agnostic aec.
   options.delay_agnostic_aec.Set(false);
   options.extended_filter_aec.Set(false);
   options.echo_cancellation.Set(false);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
   EXPECT_FALSE(ec_enabled);
   // Turning delay agnostic aec back on should also turn on echo cancellation.
   options.delay_agnostic_aec.Set(true);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);
-  voe_.GetEcMetricsStatus(ec_metrics_enabled);
   EXPECT_TRUE(ec_enabled);
-  EXPECT_TRUE(ec_metrics_enabled);
+  EXPECT_TRUE(voe_.ec_metrics_enabled());
   EXPECT_EQ(ec_mode, webrtc::kEcConference);
 
   // Turn off AGC
   options.auto_gain_control.Set(false);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   EXPECT_FALSE(agc_enabled);
 
   // Turn AGC back on
   options.auto_gain_control.Set(true);
@@ skipping 27 matching lines @@
   EXPECT_EQ(webrtc::kEcConference, ec_mode);
   EXPECT_FALSE(ns_enabled);
   EXPECT_EQ(webrtc::kNsHighSuppression, ns_mode);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, DefaultOptions) {
   EXPECT_TRUE(SetupEngineWithSendStream());
 
   bool ec_enabled;
   webrtc::EcModes ec_mode;
-  bool ec_metrics_enabled;
   bool agc_enabled;
   webrtc::AgcModes agc_mode;
   bool ns_enabled;
   webrtc::NsModes ns_mode;
   bool highpass_filter_enabled;
   bool stereo_swapping_enabled;
   bool typing_detection_enabled;
 
   voe_.GetEcStatus(ec_enabled, ec_mode);
-  voe_.GetEcMetricsStatus(ec_metrics_enabled);
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
   stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
   voe_.GetTypingDetectionStatus(typing_detection_enabled);
   EXPECT_TRUE(ec_enabled);
   EXPECT_TRUE(agc_enabled);
   EXPECT_TRUE(ns_enabled);
   EXPECT_TRUE(highpass_filter_enabled);
   EXPECT_TRUE(typing_detection_enabled);
@@ skipping 241 matching lines @@
   for (uint32_t ssrc : ssrcs) {
     EXPECT_TRUE(media_channel->AddRecvStream(
         cricket::StreamParams::CreateLegacy(ssrc)));
   }
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 
   // Combined BWE should be disabled.
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
-    EXPECT_EQ(false, s->GetConfig().combined_audio_video_bwe);
+    EXPECT_FALSE(s->GetConfig().combined_audio_video_bwe);
   }
 
   // Enable combined BWE option - now it should be set up.
   send_parameters_.options.combined_audio_video_bwe.Set(true);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(true, s->GetConfig().combined_audio_video_bwe);
   }
 
   // Disable combined BWE option - should be disabled again.
   send_parameters_.options.combined_audio_video_bwe.Set(false);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
   for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
-    EXPECT_EQ(false, s->GetConfig().combined_audio_video_bwe);
+    EXPECT_FALSE(s->GetConfig().combined_audio_video_bwe);
   }
 
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
   // Test that adding receive streams after enabling combined bandwidth
   // estimation will correctly configure each channel.
   EXPECT_TRUE(SetupEngineWithSendStream());
   cricket::WebRtcVoiceMediaChannel* media_channel =
@@ skipping 274 matching lines @@
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   rtc::scoped_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::AudioOptions(),
                                            call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }