MediaController/Call instantiation.

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.
  */
 
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/gunit.h"
+#include "webrtc/call.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"
 #include "webrtc/p2p/base/fakesession.h"
 #include "talk/session/media/channel.h"
@@ skipping 75 matching lines @@
     cricket::VoiceMediaChannel::Error error() const {
       return error_;
     }
 
    private:
     uint32 ssrc_;
     cricket::VoiceMediaChannel::Error error_;
   };
 
   WebRtcVoiceEngineTestFake()
-      : voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
+      : call_(webrtc::Call::Config()),
+        voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
         trace_wrapper_(new FakeVoETraceWrapper()),
         engine_(new FakeVoEWrapper(&voe_), trace_wrapper_),
         channel_(nullptr) {
     options_conference_.conference_mode.Set(true);
     options_adjust_agc_.adjust_agc_delta.Set(-10);
   }
   bool SetupEngineWithoutStream() {
     if (!engine_.Init(rtc::Thread::Current())) {
       return false;
     }
-    channel_ = engine_.CreateChannel(cricket::AudioOptions());
+    channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
     return (channel_ != nullptr);
   }
   bool SetupEngine() {
     if (!SetupEngineWithoutStream()) {
       return false;
     }
     return channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrc1));
   }
   void SetupForMultiSendStream() {
@@ skipping 12 matching lines @@
     rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len);
     channel_->OnPacketReceived(&packet, rtc::PacketTime());
   }
   void TearDown() override {
     delete channel_;
     engine_.Terminate();
   }
 
   void TestInsertDtmf(uint32 ssrc, bool caller) {
     EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-    channel_ = engine_.CreateChannel(cricket::AudioOptions());
+    channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
     EXPECT_TRUE(channel_ != nullptr);
     if (caller) {
       // if this is a caller, local description will be applied and add the
       // send stream.
       EXPECT_TRUE(channel_->AddSendStream(
           cricket::StreamParams::CreateLegacy(kSsrc1)));
     }
     int channel_id = voe_.GetLastChannel();
 
     // Test we can only InsertDtmf when the other side supports telephone-event.
@@ skipping 138 matching lines @@
     EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(new_channel_num, ext));
 
     // Ensure all extensions go back off with an empty list.
     extensions.clear();
     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(new_channel_num, ext));
   }
 
  protected:
+  cricket::FakeCall call_;
   cricket::FakeWebRtcVoiceEngine voe_;
   FakeVoETraceWrapper* trace_wrapper_;
   cricket::WebRtcVoiceEngine engine_;
   cricket::VoiceMediaChannel* channel_;
 
   cricket::AudioOptions options_conference_;
   cricket::AudioOptions options_adjust_agc_;
 };
 
 // Tests that our stub library "works".
 TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) {
   EXPECT_FALSE(voe_.IsInited());
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   EXPECT_TRUE(voe_.IsInited());
   engine_.Terminate();
   EXPECT_FALSE(voe_.IsInited());
 }
 
 // Tests that we can create and destroy a channel.
 TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 }
 
 // Tests that we properly handle failures in CreateChannel.
 TEST_F(WebRtcVoiceEngineTestFake, CreateChannelFail) {
   voe_.set_fail_create_channel(true);
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_ == nullptr);
 }
 
 // Tests that the list of supported codecs is created properly and ordered
 // correctly
 TEST_F(WebRtcVoiceEngineTestFake, CodecPreference) {
   const std::vector<cricket::AudioCodec>& codecs = engine_.codecs();
   ASSERT_FALSE(codecs.empty());
   EXPECT_STRCASEEQ("opus", codecs[0].name.c_str());
   EXPECT_EQ(48000, codecs[0].clockrate);
@@ skipping 288 matching lines @@
   TestSendBandwidth(kPcmuCodec, 1, false, 64000);
   TestSendBandwidth(kPcmuCodec, 128000, true, 64000);
   TestSendBandwidth(kPcmuCodec, 32000, false, 64000);
   TestSendBandwidth(kPcmuCodec, 64000, true, 64000);
   TestSendBandwidth(kPcmuCodec, 63999, false, 64000);
   TestSendBandwidth(kPcmuCodec, 64001, true, 64000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
   EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
 
   int desired_bitrate = 128000;
   EXPECT_TRUE(channel_->SetMaxSendBandwidth(desired_bitrate));
 
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
 
   int channel_num = voe_.GetLastChannel();
@@ skipping 353 matching lines @@
   codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                                                     cricket::kParamValueEmpty));
   EXPECT_FALSE(voe_.GetNACK(channel_num));
   EXPECT_TRUE(channel_->SetSendCodecs(codecs));
   EXPECT_TRUE(voe_.GetNACK(channel_num));
 }
 
 // Test that we can enable NACK with opus as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 
   int channel_num = voe_.GetLastChannel();
   std::vector<cricket::AudioCodec> codecs;
   codecs.push_back(kOpusCodec);
   codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                                                     cricket::kParamValueEmpty));
   EXPECT_FALSE(voe_.GetNACK(channel_num));
   EXPECT_TRUE(channel_->SetSendCodecs(codecs));
   EXPECT_FALSE(voe_.GetNACK(channel_num));
@@ skipping 559 matching lines @@
   EXPECT_TRUE(voe_.GetVAD(channel_num));
   EXPECT_FALSE(voe_.GetRED(channel_num));
   EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
   EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
   EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
 }
 
 // Test that we set VAD and DTMF types correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 
   int channel_num = voe_.GetLastChannel();
   std::vector<cricket::AudioCodec> codecs;
   codecs.push_back(kIsacCodec);
   codecs.push_back(kPcmuCodec);
   // TODO(juberti): cn 32000
   codecs.push_back(kCn16000Codec);
   codecs.push_back(kCn8000Codec);
   codecs.push_back(kTelephoneEventCodec);
@@ skipping 96 matching lines @@
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(96, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_TRUE(voe_.GetRED(channel_num));
   EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num));
 }
 
 // Test that we set up RED correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 
   int channel_num = voe_.GetLastChannel();
   std::vector<cricket::AudioCodec> codecs;
   codecs.push_back(kRedCodec);
   codecs.push_back(kIsacCodec);
   codecs.push_back(kPcmuCodec);
   codecs[0].id = 127;
   codecs[0].params[""] = "96/96";
   codecs[1].id = 96;
@@ skipping 668 matching lines @@
   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);
 }
 
 // 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(cricket::AudioOptions());
+  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_->SetOptions(options_conference_));
 
   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));
@@ skipping 550 matching lines @@
   EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv);
   EXPECT_EQ(set_config.digitalCompressionGaindB,
             config.digitalCompressionGaindB);
   EXPECT_EQ(set_config.limiterEnable, config.limiterEnable);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
   EXPECT_TRUE(SetupEngine());
   rtc::scoped_ptr<cricket::WebRtcVoiceMediaChannel> channel1(
       static_cast<cricket::WebRtcVoiceMediaChannel*>(
-          engine_.CreateChannel(cricket::AudioOptions())));
+          engine_.CreateChannel(&call_, cricket::AudioOptions())));
   rtc::scoped_ptr<cricket::WebRtcVoiceMediaChannel> channel2(
       static_cast<cricket::WebRtcVoiceMediaChannel*>(
-          engine_.CreateChannel(cricket::AudioOptions())));
+          engine_.CreateChannel(&call_, cricket::AudioOptions())));
 
   // Have to add a stream to make SetSend work.
   cricket::StreamParams stream1;
   stream1.ssrcs.push_back(1);
   channel1->AddSendStream(stream1);
   cricket::StreamParams stream2;
   stream2.ssrcs.push_back(2);
   channel2->AddSendStream(stream2);
 
   // AEC and AGC and NS
@@ skipping 91 matching lines @@
   voe_.GetNsStatus(ns_enabled, ns_mode);
   EXPECT_TRUE(ec_enabled);
   EXPECT_FALSE(agc_enabled);
   EXPECT_FALSE(ns_enabled);
 }
 
 // This test verifies DSCP settings are properly applied on voice media channel.
 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
   EXPECT_TRUE(SetupEngine());
   rtc::scoped_ptr<cricket::VoiceMediaChannel> channel(
-      engine_.CreateChannel(cricket::AudioOptions()));
+      engine_.CreateChannel(&call_, cricket::AudioOptions()));
   rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
       new cricket::FakeNetworkInterface);
   channel->SetInterface(network_interface.get());
   cricket::AudioOptions options;
   options.dscp.Set(true);
   EXPECT_TRUE(channel->SetOptions(options));
   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));
@@ skipping 50 matching lines @@
 
   EXPECT_TRUE(channel_->SetOutputScaling(kSsrc2, 2, 1));
   channel_id = voe_.GetLastChannel();
   EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale));
   EXPECT_EQ(0, voe_.GetOutputVolumePan(channel_id, left, right));
   EXPECT_DOUBLE_EQ(2, left * scale);
   EXPECT_DOUBLE_EQ(1, right * scale);
 }
 
 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());
+  ASSERT_EQ(2, call_.GetAudioReceiveStreams().size());
   EXPECT_EQ(kSyncLabel,
-            call.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group)
+            call_.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group)
       << "SyncGroup should be set based on sync_label";
   EXPECT_EQ(kSyncLabel,
-            call.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group)
+            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;
+  std::vector<uint32> ssrcs;
+  ssrcs.push_back(223);
+  ssrcs.push_back(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)));
+  for (uint32 ssrc : ssrcs) {
+    EXPECT_TRUE(media_channel->AddRecvStream(
+        cricket::StreamParams::CreateLegacy(ssrc)));
+  }
+  EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 
-  // 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);
+  // Combined BWE should be disabled.
+  for (uint32 ssrc : ssrcs) {
+    const auto* s = call_.GetAudioReceiveStream(ssrc);
+    EXPECT_NE(nullptr, s);
+    EXPECT_EQ(false, s->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);
+  for (uint32 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.
   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);
+  for (uint32 ssrc : ssrcs) {
+    const auto* s = call_.GetAudioReceiveStream(ssrc);
+    EXPECT_NE(nullptr, s);
+    EXPECT_EQ(false, s->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());
+  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.
-  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_NE(nullptr, call_.GetAudioReceiveStream(kSsrcs[i]));
   }
-  EXPECT_EQ(ARRAY_SIZE(kSsrcs), call.GetAudioReceiveStreams().size());
-
-  media_channel->SetCall(nullptr);
-  EXPECT_EQ(0, call.GetAudioReceiveStreams().size());
+  EXPECT_EQ(ARRAY_SIZE(kSsrcs), 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);
+  cricket::AudioOptions options;
+  options.combined_audio_video_bwe.Set(true);
+  EXPECT_TRUE(media_channel->SetOptions(options));
   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());
+  EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
   for (uint32 ssrc : ssrcs) {
-    const auto* s = call.GetAudioReceiveStream(ssrc);
+    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());
+  EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
   for (uint32 ssrc : ssrcs) {
-    const auto* s = call.GetAudioReceiveStream(ssrc);
+    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);
+    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());
+  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
   const cricket::FakeAudioReceiveStream* s =
-      call.GetAudioReceiveStream(kAudioSsrc);
+      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);
 }
@@ skipping 66 matching lines @@
   // 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()));
+  rtc::scoped_ptr<webrtc::Call> call(
+      webrtc::Call::Create(webrtc::Call::Config()));
   cricket::VoiceMediaChannel* channel =
-      engine.CreateChannel(cricket::AudioOptions());
+      engine.CreateChannel(call.get(), cricket::AudioOptions());
   EXPECT_TRUE(channel != nullptr);
   delete channel;
   engine.Terminate();
 
   // Reinit to catch regression where VoiceEngineObserver reference is lost
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   engine.Terminate();
 }
 
 // Tests that the library is configured with the codecs we want.
@@ skipping 73 matching lines @@
     }
   }
 
   engine.Terminate();
 }
 
 // Tests that VoE supports at least 32 channels
 TEST(WebRtcVoiceEngineTest, Has32Channels) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
+  rtc::scoped_ptr<webrtc::Call> call(
+      webrtc::Call::Create(webrtc::Call::Config()));
 
   cricket::VoiceMediaChannel* channels[32];
   int num_channels = 0;
-
   while (num_channels < ARRAY_SIZE(channels)) {
     cricket::VoiceMediaChannel* channel =
-        engine.CreateChannel(cricket::AudioOptions());
+        engine.CreateChannel(call.get(), cricket::AudioOptions());
     if (!channel)
       break;
-
     channels[num_channels++] = channel;
   }
 
   int expected = ARRAY_SIZE(channels);
   EXPECT_EQ(expected, num_channels);
 
   while (num_channels > 0) {
     delete channels[--num_channels];
   }
 
   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);
+  rtc::scoped_ptr<webrtc::Call> call(
+      webrtc::Call::Create(webrtc::Call::Config()));
+  cricket::WebRtcVoiceMediaChannel channel(&engine, call.get());
   EXPECT_TRUE(channel.SetRecvCodecs(engine.codecs()));
 }