Revert of Revert "Move test cases for more natural ordering"

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,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifdef WIN32
-#include "webrtc/base/win32.h"
-#include <objbase.h>
-#endif
-
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/gunit.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakemediaprocessor.h"
 #include "talk/media/base/fakenetworkinterface.h"
 #include "talk/media/base/fakertp.h"
 #include "talk/media/webrtc/fakewebrtccall.h"
 #include "talk/media/webrtc/fakewebrtcvoiceengine.h"
 #include "talk/media/webrtc/webrtcvoiceengine.h"
@@ skipping 3085 matching lines @@
   EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
   // Verify previous value is not modified if dscp option is not set.
   cricket::AudioOptions options1;
   EXPECT_TRUE(channel->SetOptions(options1));
   EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
   options.dscp.Set(false);
   EXPECT_TRUE(channel->SetOptions(options));
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
 }
 
-TEST(WebRtcVoiceEngineTest, TestDefaultOptionsBeforeInit) {
-  cricket::WebRtcVoiceEngine engine;
-  cricket::AudioOptions options = engine.GetOptions();
-  // The default options should have at least a few things set. We purposefully
-  // don't check the option values here, though.
-  EXPECT_TRUE(options.echo_cancellation.IsSet());
-  EXPECT_TRUE(options.auto_gain_control.IsSet());
-  EXPECT_TRUE(options.noise_suppression.IsSet());
-}
-
 // Test that GetReceiveChannelNum returns the default channel for the first
 // recv stream in 1-1 calls.
 TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelNumIn1To1Calls) {
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
         static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   // Test that GetChannelNum returns the default channel if the SSRC is unknown.
   EXPECT_EQ(media_channel->voe_channel(),
             media_channel->GetReceiveChannelNum(0));
   cricket::StreamParams stream;
@@ skipping 29 matching lines @@
   cricket::StreamParams stream;
   stream.ssrcs.push_back(kSsrc2);
   EXPECT_TRUE(channel_->AddRecvStream(stream));
 
   EXPECT_TRUE(channel_->SetOutputScaling(kSsrc2, 2, 1));
   EXPECT_TRUE(channel_->GetOutputScaling(kSsrc2, &left, &right));
   EXPECT_DOUBLE_EQ(2, left);
   EXPECT_DOUBLE_EQ(1, right);
 }
 
+TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
+  cricket::FakeCall call((webrtc::Call::Config()));
+  const uint32 kAudioSsrc = 123;
+  const std::string kSyncLabel = "AvSyncLabel";
+
+  EXPECT_TRUE(SetupEngine());
+  cricket::WebRtcVoiceMediaChannel* media_channel =
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  media_channel->SetCall(&call);
+  cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc);
+  sp.sync_label = kSyncLabel;
+  // Creating two channels to make sure that sync label is set properly for both
+  // the default voice channel and following ones.
+  EXPECT_TRUE(channel_->AddRecvStream(sp));
+  sp.ssrcs[0] += 1;
+  EXPECT_TRUE(channel_->AddRecvStream(sp));
+
+  ASSERT_EQ(2, call.GetAudioReceiveStreams().size());
+  EXPECT_EQ(kSyncLabel,
+            call.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group)
+      << "SyncGroup should be set based on sync_label";
+  EXPECT_EQ(kSyncLabel,
+            call.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group)
+      << "SyncGroup should be set based on sync_label";
+
+  media_channel->SetCall(nullptr);
+}
+
+TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) {
+  // Test that changing the combined_audio_video_bwe option results in the
+  // expected state changes on an associated Call.
+  cricket::FakeCall call((webrtc::Call::Config()));
+  const uint32 kAudioSsrc1 = 223;
+  const uint32 kAudioSsrc2 = 224;
+
+  EXPECT_TRUE(SetupEngine());
+  cricket::WebRtcVoiceMediaChannel* media_channel =
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  const auto& rtp_extensions = engine_.rtp_header_extensions();
+  media_channel->SetRecvRtpHeaderExtensions(rtp_extensions);
+  media_channel->SetCall(&call);
+  EXPECT_TRUE(media_channel->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(kAudioSsrc1)));
+  EXPECT_TRUE(media_channel->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(kAudioSsrc2)));
+
+  // Combined BWE should not be set up yet.
+  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
+  EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc1)
+                   ->GetConfig()
+                   .combined_audio_video_bwe);
+  EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc2)
+                   ->GetConfig()
+                   .combined_audio_video_bwe);
+
+  // Enable combined BWE option - now it should be set up.
+  cricket::AudioOptions options;
+  options.combined_audio_video_bwe.Set(true);
+  EXPECT_TRUE(media_channel->SetOptions(options));
+  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
+  EXPECT_TRUE(call.GetAudioReceiveStream(kAudioSsrc1)
+                  ->GetConfig()
+                  .combined_audio_video_bwe);
+  EXPECT_TRUE(call.GetAudioReceiveStream(kAudioSsrc2)
+                  ->GetConfig()
+                  .combined_audio_video_bwe);
+
+  // Disable combined BWE option - should be disabled again.
+  options.combined_audio_video_bwe.Set(false);
+  EXPECT_TRUE(media_channel->SetOptions(options));
+  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
+  EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc1)
+                   ->GetConfig()
+                   .combined_audio_video_bwe);
+  EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc2)
+                   ->GetConfig()
+                   .combined_audio_video_bwe);
+
+  media_channel->SetCall(nullptr);
+}
+
+TEST_F(WebRtcVoiceEngineTestFake, SetCallConfiguresAudioReceiveChannels) {
+  // Test that calling SetCall() on the voice media channel results in the
+  // expected state changes in Call.
+  cricket::FakeCall call((webrtc::Call::Config()));
+  cricket::FakeCall call2((webrtc::Call::Config()));
+  const uint32 kAudioSsrc1 = 223;
+  const uint32 kAudioSsrc2 = 224;
+
+  EXPECT_TRUE(SetupEngine());
+  cricket::WebRtcVoiceMediaChannel* media_channel =
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  EXPECT_TRUE(media_channel->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(kAudioSsrc1)));
+  EXPECT_TRUE(media_channel->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(kAudioSsrc2)));
+
+  // Combined BWE should not be set up yet.
+  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
+
+  // Register - should be enabled.
+  media_channel->SetCall(&call);
+  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
+  EXPECT_NE(nullptr, call.GetAudioReceiveStream(kAudioSsrc1));
+  EXPECT_NE(nullptr, call.GetAudioReceiveStream(kAudioSsrc2));
+
+  // Re-register - should now be enabled on new call.
+  media_channel->SetCall(&call2);
+  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
+  EXPECT_EQ(2, call2.GetAudioReceiveStreams().size());
+  EXPECT_NE(nullptr, call2.GetAudioReceiveStream(kAudioSsrc1));
+  EXPECT_NE(nullptr, call2.GetAudioReceiveStream(kAudioSsrc2));
+
+  // Unregister - should be disabled again.
+  media_channel->SetCall(nullptr);
+  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
+}
+
+TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
+  // Test that adding receive streams after enabling combined bandwidth
+  // estimation will correctly configure each channel.
+  cricket::FakeCall call((webrtc::Call::Config()));
+
+  EXPECT_TRUE(SetupEngine());
+  cricket::WebRtcVoiceMediaChannel* media_channel =
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  media_channel->SetCall(&call);
+  cricket::AudioOptions options;
+  options.combined_audio_video_bwe.Set(true);
+  EXPECT_TRUE(media_channel->SetOptions(options));
+
+  static const uint32 kSsrcs[] = {1, 2, 3, 4};
+  for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs); ++i) {
+    EXPECT_TRUE(media_channel->AddRecvStream(
+        cricket::StreamParams::CreateLegacy(kSsrcs[i])));
+    EXPECT_NE(nullptr, call.GetAudioReceiveStream(kSsrcs[i]));
+    EXPECT_TRUE(call.GetAudioReceiveStream(kSsrcs[i])
+                    ->GetConfig()
+                    .combined_audio_video_bwe);
+  }
+  EXPECT_EQ(ARRAY_SIZE(kSsrcs), call.GetAudioReceiveStreams().size());
+
+  media_channel->SetCall(nullptr);
+  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
+}
+
+TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
+  // Test that setting the header extensions results in the expected state
+  // changes on an associated Call.
+  cricket::FakeCall call((webrtc::Call::Config()));
+  std::vector<uint32> ssrcs;
+  ssrcs.push_back(223);
+  ssrcs.push_back(224);
+
+  EXPECT_TRUE(SetupEngine());
+  cricket::WebRtcVoiceMediaChannel* media_channel =
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  media_channel->SetCall(&call);
+  for (uint32 ssrc : ssrcs) {
+    EXPECT_TRUE(media_channel->AddRecvStream(
+        cricket::StreamParams::CreateLegacy(ssrc)));
+  }
+
+  // Combined BWE should be set up, but with no configured extensions.
+  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
+  for (uint32 ssrc : ssrcs) {
+    const auto* s = call.GetAudioReceiveStream(ssrc);
+    EXPECT_NE(nullptr, s);
+    EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
+  }
+
+  // Set up receive extensions.
+  const auto& e_exts = engine_.rtp_header_extensions();
+  channel_->SetRecvRtpHeaderExtensions(e_exts);
+  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
+  for (uint32 ssrc : ssrcs) {
+    const auto* s = call.GetAudioReceiveStream(ssrc);
+    EXPECT_NE(nullptr, s);
+    const auto& s_exts = s->GetConfig().rtp.extensions;
+    EXPECT_EQ(e_exts.size(), s_exts.size());
+    for (const auto& e_ext : e_exts) {
+      for (const auto& s_ext : s_exts) {
+        if (e_ext.id == s_ext.id) {
+          EXPECT_EQ(e_ext.uri, s_ext.name);
+        }
+      }
+    }
+  }
+
+  // Disable receive extensions.
+  std::vector<cricket::RtpHeaderExtension> extensions;
+  channel_->SetRecvRtpHeaderExtensions(extensions);
+  for (uint32 ssrc : ssrcs) {
+    const auto* s = call.GetAudioReceiveStream(ssrc);
+    EXPECT_NE(nullptr, s);
+    EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
+  }
+
+  media_channel->SetCall(nullptr);
+}
+
+TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
+  // Test that packets are forwarded to the Call when configured accordingly.
+  cricket::FakeCall call((webrtc::Call::Config()));
+  const uint32 kAudioSsrc = 1;
+  rtc::Buffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame));
+  static const unsigned char kRtcp[] = {
+    0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  };
+  rtc::Buffer kRtcpPacket(kRtcp, sizeof(kRtcp));
+
+  EXPECT_TRUE(SetupEngine());
+  cricket::WebRtcVoiceMediaChannel* media_channel =
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  cricket::AudioOptions options;
+  options.combined_audio_video_bwe.Set(true);
+  EXPECT_TRUE(media_channel->SetOptions(options));
+  EXPECT_TRUE(media_channel->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(kAudioSsrc)));
+
+  // Call not set on media channel, so no packets can be forwarded.
+  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
+  channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime());
+  channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime());
+  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
+
+  // Set Call, now there should be a receive stream which is forwarded packets.
+  media_channel->SetCall(&call);
+  EXPECT_EQ(1, call.GetAudioReceiveStreams().size());
+  const cricket::FakeAudioReceiveStream* s =
+      call.GetAudioReceiveStream(kAudioSsrc);
+  EXPECT_EQ(0, s->received_packets());
+  channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime());
+  EXPECT_EQ(1, s->received_packets());
+  channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime());
+  EXPECT_EQ(2, s->received_packets());
+
+  media_channel->SetCall(nullptr);
+}
+
+// Associate channel should not set on 1:1 call, since the receive channel also
+// sends RTCP SR.
+TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelUnset1On1) {
+  EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+  int recv_ch = voe_.GetLastChannel();
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
+}
+
+// This test is an extension of AssociateChannelUnset1On1. We create two receive
+// channels. The second should be associated with the default channel, since it
+// does not send RTCP SR.
+TEST_F(WebRtcVoiceEngineTestFake, AssociateDefaultChannelOnSecondRecvChannel) {
+  EXPECT_TRUE(SetupEngine());
+  cricket::WebRtcVoiceMediaChannel* media_channel =
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  int default_channel = media_channel->voe_channel();
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+  int recv_ch_1 = voe_.GetLastChannel();
+  EXPECT_EQ(recv_ch_1, default_channel);
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
+  int recv_ch_2 = voe_.GetLastChannel();
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_1), -1);
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_2), default_channel);
+  // Add send stream, the association remains.
+  EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(3)));
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_1), -1);
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_2), default_channel);
+}
+
+// In conference mode, all receive channels should be associated with the
+// default channel, since they do not send RTCP SR.
+TEST_F(WebRtcVoiceEngineTestFake, AssociateDefaultChannelOnConference) {
+  EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  cricket::WebRtcVoiceMediaChannel* media_channel =
+      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  int default_channel = media_channel->voe_channel();
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+  int recv_ch = voe_.GetLastChannel();
+  EXPECT_NE(recv_ch, default_channel);
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
+  EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
+}
+
+TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelResetUponDeleteChannnel) {
+  EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+  int recv_ch = voe_.GetLastChannel();
+
+  EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
+  int send_ch = voe_.GetLastChannel();
+
+  // Manually associate |recv_ch| to |send_ch|. This test is to verify a
+  // deleting logic, i.e., deleting |send_ch| will reset the associate send
+  // channel of |recv_ch|.This is not a common case, since， normally, only the
+  // default channel can be associated. However, the default is not deletable.
+  // So we force the |recv_ch| to associate with a non-default channel.
+  EXPECT_EQ(0, voe_.AssociateSendChannel(recv_ch, send_ch));
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), send_ch);
+
+  EXPECT_TRUE(channel_->RemoveSendStream(2));
+  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
+}
+
 // Tests for the actual WebRtc VoE library.
 
+TEST(WebRtcVoiceEngineTest, TestDefaultOptionsBeforeInit) {
+  cricket::WebRtcVoiceEngine engine;
+  cricket::AudioOptions options = engine.GetOptions();
+  // The default options should have at least a few things set. We purposefully
+  // don't check the option values here, though.
+  EXPECT_TRUE(options.echo_cancellation.IsSet());
+  EXPECT_TRUE(options.auto_gain_control.IsSet());
+  EXPECT_TRUE(options.noise_suppression.IsSet());
+}
+
 // Tests that the library initializes and shuts down properly.
 TEST(WebRtcVoiceEngineTest, StartupShutdown) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   cricket::VoiceMediaChannel* channel =
       engine.CreateChannel(cricket::AudioOptions());
   EXPECT_TRUE(channel != nullptr);
   delete channel;
   engine.Terminate();
 
@@ skipping 109 matching lines @@
   engine.Terminate();
 }
 
 // Test that we set our preferred codecs properly.
 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   cricket::WebRtcVoiceMediaChannel channel(&engine);
   EXPECT_TRUE(channel.SetRecvCodecs(engine.codecs()));
 }
-
-#ifdef WIN32
-// Test our workarounds to WebRtc VoE' munging of the coinit count
-TEST(WebRtcVoiceEngineTest, CoInitialize) {
-  cricket::WebRtcVoiceEngine* engine = new cricket::WebRtcVoiceEngine();
-
-  // Initial refcount should be 0.
-  EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
-
-  // Engine should start even with COM already inited.
-  EXPECT_TRUE(engine->Init(rtc::Thread::Current()));
-  engine->Terminate();
-  EXPECT_TRUE(engine->Init(rtc::Thread::Current()));
-  engine->Terminate();
-
-  // Refcount after terminate should be 1 (in reality 3); test if it is nonzero.
-  EXPECT_EQ(S_FALSE, CoInitializeEx(NULL, COINIT_MULTITHREADED));
-  // Decrement refcount to (hopefully) 0.
-  CoUninitialize();
-  CoUninitialize();
-  delete engine;
-
-  // Ensure refcount is 0.
-  EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
-  CoUninitialize();
-}
-#endif
-
-TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
-  cricket::FakeCall call((webrtc::Call::Config()));
-  const uint32 kAudioSsrc = 123;
-  const std::string kSyncLabel = "AvSyncLabel";
-
-  EXPECT_TRUE(SetupEngine());
-  cricket::WebRtcVoiceMediaChannel* media_channel =
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  media_channel->SetCall(&call);
-  cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc);
-  sp.sync_label = kSyncLabel;
-  // Creating two channels to make sure that sync label is set properly for both
-  // the default voice channel and following ones.
-  EXPECT_TRUE(channel_->AddRecvStream(sp));
-  sp.ssrcs[0] += 1;
-  EXPECT_TRUE(channel_->AddRecvStream(sp));
-
-  ASSERT_EQ(2, call.GetAudioReceiveStreams().size());
-  EXPECT_EQ(kSyncLabel,
-            call.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group)
-      << "SyncGroup should be set based on sync_label";
-  EXPECT_EQ(kSyncLabel,
-            call.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group)
-      << "SyncGroup should be set based on sync_label";
-
-  media_channel->SetCall(nullptr);
-}
-
-TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) {
-  // Test that changing the combined_audio_video_bwe option results in the
-  // expected state changes on an associated Call.
-  cricket::FakeCall call((webrtc::Call::Config()));
-  const uint32 kAudioSsrc1 = 223;
-  const uint32 kAudioSsrc2 = 224;
-
-  EXPECT_TRUE(SetupEngine());
-  cricket::WebRtcVoiceMediaChannel* media_channel =
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  const auto& rtp_extensions = engine_.rtp_header_extensions();
-  media_channel->SetRecvRtpHeaderExtensions(rtp_extensions);
-  media_channel->SetCall(&call);
-  EXPECT_TRUE(media_channel->AddRecvStream(
-      cricket::StreamParams::CreateLegacy(kAudioSsrc1)));
-  EXPECT_TRUE(media_channel->AddRecvStream(
-      cricket::StreamParams::CreateLegacy(kAudioSsrc2)));
-
-  // Combined BWE should not be set up yet.
-  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
-  EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc1)
-                   ->GetConfig()
-                   .combined_audio_video_bwe);
-  EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc2)
-                   ->GetConfig()
-                   .combined_audio_video_bwe);
-
-  // Enable combined BWE option - now it should be set up.
-  cricket::AudioOptions options;
-  options.combined_audio_video_bwe.Set(true);
-  EXPECT_TRUE(media_channel->SetOptions(options));
-  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
-  EXPECT_TRUE(call.GetAudioReceiveStream(kAudioSsrc1)
-                  ->GetConfig()
-                  .combined_audio_video_bwe);
-  EXPECT_TRUE(call.GetAudioReceiveStream(kAudioSsrc2)
-                  ->GetConfig()
-                  .combined_audio_video_bwe);
-
-  // Disable combined BWE option - should be disabled again.
-  options.combined_audio_video_bwe.Set(false);
-  EXPECT_TRUE(media_channel->SetOptions(options));
-  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
-  EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc1)
-                   ->GetConfig()
-                   .combined_audio_video_bwe);
-  EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc2)
-                   ->GetConfig()
-                   .combined_audio_video_bwe);
-
-  media_channel->SetCall(nullptr);
-}
-
-TEST_F(WebRtcVoiceEngineTestFake, SetCallConfiguresAudioReceiveChannels) {
-  // Test that calling SetCall() on the voice media channel results in the
-  // expected state changes in Call.
-  cricket::FakeCall call((webrtc::Call::Config()));
-  cricket::FakeCall call2((webrtc::Call::Config()));
-  const uint32 kAudioSsrc1 = 223;
-  const uint32 kAudioSsrc2 = 224;
-
-  EXPECT_TRUE(SetupEngine());
-  cricket::WebRtcVoiceMediaChannel* media_channel =
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  EXPECT_TRUE(media_channel->AddRecvStream(
-      cricket::StreamParams::CreateLegacy(kAudioSsrc1)));
-  EXPECT_TRUE(media_channel->AddRecvStream(
-      cricket::StreamParams::CreateLegacy(kAudioSsrc2)));
-
-  // Combined BWE should not be set up yet.
-  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
-
-  // Register - should be enabled.
-  media_channel->SetCall(&call);
-  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
-  EXPECT_NE(nullptr, call.GetAudioReceiveStream(kAudioSsrc1));
-  EXPECT_NE(nullptr, call.GetAudioReceiveStream(kAudioSsrc2));
-
-  // Re-register - should now be enabled on new call.
-  media_channel->SetCall(&call2);
-  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
-  EXPECT_EQ(2, call2.GetAudioReceiveStreams().size());
-  EXPECT_NE(nullptr, call2.GetAudioReceiveStream(kAudioSsrc1));
-  EXPECT_NE(nullptr, call2.GetAudioReceiveStream(kAudioSsrc2));
-
-  // Unregister - should be disabled again.
-  media_channel->SetCall(nullptr);
-  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
-}
-
-TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
-  // Test that adding receive streams after enabling combined bandwidth
-  // estimation will correctly configure each channel.
-  cricket::FakeCall call((webrtc::Call::Config()));
-
-  EXPECT_TRUE(SetupEngine());
-  cricket::WebRtcVoiceMediaChannel* media_channel =
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  media_channel->SetCall(&call);
-  cricket::AudioOptions options;
-  options.combined_audio_video_bwe.Set(true);
-  EXPECT_TRUE(media_channel->SetOptions(options));
-
-  static const uint32 kSsrcs[] = {1, 2, 3, 4};
-  for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs); ++i) {
-    EXPECT_TRUE(media_channel->AddRecvStream(
-        cricket::StreamParams::CreateLegacy(kSsrcs[i])));
-    EXPECT_NE(nullptr, call.GetAudioReceiveStream(kSsrcs[i]));
-    EXPECT_TRUE(call.GetAudioReceiveStream(kSsrcs[i])
-                    ->GetConfig()
-                    .combined_audio_video_bwe);
-  }
-  EXPECT_EQ(ARRAY_SIZE(kSsrcs), call.GetAudioReceiveStreams().size());
-
-  media_channel->SetCall(nullptr);
-  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
-}
-
-TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
-  // Test that setting the header extensions results in the expected state
-  // changes on an associated Call.
-  cricket::FakeCall call((webrtc::Call::Config()));
-  std::vector<uint32> ssrcs;
-  ssrcs.push_back(223);
-  ssrcs.push_back(224);
-
-  EXPECT_TRUE(SetupEngine());
-  cricket::WebRtcVoiceMediaChannel* media_channel =
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  media_channel->SetCall(&call);
-  for (uint32 ssrc : ssrcs) {
-    EXPECT_TRUE(media_channel->AddRecvStream(
-        cricket::StreamParams::CreateLegacy(ssrc)));
-  }
-
-  // Combined BWE should be set up, but with no configured extensions.
-  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
-  for (uint32 ssrc : ssrcs) {
-    const auto* s = call.GetAudioReceiveStream(ssrc);
-    EXPECT_NE(nullptr, s);
-    EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
-  }
-
-  // Set up receive extensions.
-  const auto& e_exts = engine_.rtp_header_extensions();
-  channel_->SetRecvRtpHeaderExtensions(e_exts);
-  EXPECT_EQ(2, call.GetAudioReceiveStreams().size());
-  for (uint32 ssrc : ssrcs) {
-    const auto* s = call.GetAudioReceiveStream(ssrc);
-    EXPECT_NE(nullptr, s);
-    const auto& s_exts = s->GetConfig().rtp.extensions;
-    EXPECT_EQ(e_exts.size(), s_exts.size());
-    for (const auto& e_ext : e_exts) {
-      for (const auto& s_ext : s_exts) {
-        if (e_ext.id == s_ext.id) {
-          EXPECT_EQ(e_ext.uri, s_ext.name);
-        }
-      }
-    }
-  }
-
-  // Disable receive extensions.
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  channel_->SetRecvRtpHeaderExtensions(extensions);
-  for (uint32 ssrc : ssrcs) {
-    const auto* s = call.GetAudioReceiveStream(ssrc);
-    EXPECT_NE(nullptr, s);
-    EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
-  }
-
-  media_channel->SetCall(nullptr);
-}
-
-TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
-  // Test that packets are forwarded to the Call when configured accordingly.
-  cricket::FakeCall call((webrtc::Call::Config()));
-  const uint32 kAudioSsrc = 1;
-  rtc::Buffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  static const unsigned char kRtcp[] = {
-    0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
-    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-  };
-  rtc::Buffer kRtcpPacket(kRtcp, sizeof(kRtcp));
-
-  EXPECT_TRUE(SetupEngine());
-  cricket::WebRtcVoiceMediaChannel* media_channel =
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  cricket::AudioOptions options;
-  options.combined_audio_video_bwe.Set(true);
-  EXPECT_TRUE(media_channel->SetOptions(options));
-  EXPECT_TRUE(media_channel->AddRecvStream(
-      cricket::StreamParams::CreateLegacy(kAudioSsrc)));
-
-  // Call not set on media channel, so no packets can be forwarded.
-  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
-  channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime());
-  channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime());
-  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
-
-  // Set Call, now there should be a receive stream which is forwarded packets.
-  media_channel->SetCall(&call);
-  EXPECT_EQ(1, call.GetAudioReceiveStreams().size());
-  const cricket::FakeAudioReceiveStream* s =
-      call.GetAudioReceiveStream(kAudioSsrc);
-  EXPECT_EQ(0, s->received_packets());
-  channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime());
-  EXPECT_EQ(1, s->received_packets());
-  channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime());
-  EXPECT_EQ(2, s->received_packets());
-
-  media_channel->SetCall(nullptr);
-}
-
-// Associate channel should not set on 1:1 call, since the receive channel also
-// sends RTCP SR.
-TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelUnset1On1) {
-  EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
-  int recv_ch = voe_.GetLastChannel();
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
-}
-
-// This test is an extension of AssociateChannelUnset1On1. We create two receive
-// channels. The second should be associated with the default channel, since it
-// does not send RTCP SR.
-TEST_F(WebRtcVoiceEngineTestFake, AssociateDefaultChannelOnSecondRecvChannel) {
-  EXPECT_TRUE(SetupEngine());
-  cricket::WebRtcVoiceMediaChannel* media_channel =
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  int default_channel = media_channel->voe_channel();
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
-  int recv_ch_1 = voe_.GetLastChannel();
-  EXPECT_EQ(recv_ch_1, default_channel);
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
-  int recv_ch_2 = voe_.GetLastChannel();
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_1), -1);
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_2), default_channel);
-  // Add send stream, the association remains.
-  EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(3)));
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_1), -1);
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_2), default_channel);
-}
-
-// In conference mode, all receive channels should be associated with the
-// default channel, since they do not send RTCP SR.
-TEST_F(WebRtcVoiceEngineTestFake, AssociateDefaultChannelOnConference) {
-  EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  cricket::WebRtcVoiceMediaChannel* media_channel =
-      static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  int default_channel = media_channel->voe_channel();
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
-  int recv_ch = voe_.GetLastChannel();
-  EXPECT_NE(recv_ch, default_channel);
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
-  EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
-}
-
-TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelResetUponDeleteChannnel) {
-  EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
-  int recv_ch = voe_.GetLastChannel();
-
-  EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
-  int send_ch = voe_.GetLastChannel();
-
-  // Manually associate |recv_ch| to |send_ch|. This test is to verify a
-  // deleting logic, i.e., deleting |send_ch| will reset the associate send
-  // channel of |recv_ch|.This is not a common case, since， normally, only the
-  // default channel can be associated. However, the default is not deletable.
-  // So we force the |recv_ch| to associate with a non-default channel.
-  EXPECT_EQ(0, voe_.AssociateSendChannel(recv_ch, send_ch));
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), send_ch);
-
-  EXPECT_TRUE(channel_->RemoveSendStream(2));
-  EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
-}