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::AudioSendStream::Stats& GetAudioSendStreamStats() const {
+    static webrtc::AudioSendStream::Stats stats;

[tommi, 2015/10/23 12:50:37]

can you add a comment why this is static and not e.g. a member? (is it an
optimization?) 

[the sun, 2015/10/23 15:14:17]

Nah, if that's required I rather return by value.

+    if (stats.local_ssrc == 0) {
+      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& kStats = GetAudioSendStreamStats();

[tommi, 2015/10/23 12:50:37]

kStats -> stats since this is not a compile time constant

[the sun, 2015/10/23 15:14:17]

Done.

+    EXPECT_EQ(info.ssrc(), kStats.local_ssrc);
+    EXPECT_EQ(info.bytes_sent, kStats.bytes_sent);
+    EXPECT_EQ(info.packets_sent, kStats.packets_sent);
+    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.rtt_ms, kStats.rtt_ms);
+    EXPECT_EQ(info.audio_level, kStats.audio_level);
+    EXPECT_EQ(info.aec_quality_min, kStats.aec_quality_min);
+    EXPECT_EQ(info.echo_delay_median_ms, kStats.echo_delay_median_ms);
+    EXPECT_EQ(info.echo_delay_std_ms, kStats.echo_delay_std_ms);
+    EXPECT_EQ(info.echo_return_loss, kStats.echo_return_loss);
+    EXPECT_EQ(info.echo_return_loss_enhancement,
+              kStats.echo_return_loss_enhancement);
+    // TODO(solenberg): Move typing noise detection into AudioSendStream.
+    // EXPECT_EQ(info.typing_noise_detected, kStats.typing_noise_detected);
+  }
+
   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.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 = 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;
     }
     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.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);
     EXPECT_EQ(info.jitter_buffer_preferred_ms,
               kStats.jitter_buffer_preferred_ms);
@@ skipping 1680 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());
+  {
+    // 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);
+    }
 
-  // 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 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(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(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();
 
@@ skipping 203 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);
+  {
+    // 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(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.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 554 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));
 }