Non-constraint interfaces for all constrainable interfaces

webrtc/api/webrtcsession_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/audiotrack.h"
 #include "webrtc/api/fakemediacontroller.h"
 #include "webrtc/api/fakemetricsobserver.h"
 #include "webrtc/api/jsepicecandidate.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/api/sctputils.h"
 #include "webrtc/api/streamcollection.h"
 #include "webrtc/api/streamcollection.h"
-#include "webrtc/api/test/fakeconstraints.h"
 #include "webrtc/api/test/fakedtlsidentitystore.h"
 #include "webrtc/api/videotrack.h"
 #include "webrtc/api/webrtcsession.h"
 #include "webrtc/api/webrtcsessiondescriptionfactory.h"
 #include "webrtc/base/fakenetwork.h"
 #include "webrtc/base/firewallsocketserver.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/network.h"
 #include "webrtc/base/physicalsocketserver.h"
@@ skipping 24 matching lines @@
 using cricket::FakeVoiceMediaChannel;
 using cricket::TransportInfo;
 using rtc::SocketAddress;
 using rtc::scoped_ptr;
 using rtc::Thread;
 using webrtc::CreateSessionDescription;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::CreateSessionDescriptionRequest;
 using webrtc::DataChannel;
 using webrtc::DtlsIdentityStoreInterface;
-using webrtc::FakeConstraints;
 using webrtc::FakeMetricsObserver;
 using webrtc::IceCandidateCollection;
 using webrtc::InternalDataChannelInit;
 using webrtc::JsepIceCandidate;
 using webrtc::JsepSessionDescription;
 using webrtc::PeerConnectionFactoryInterface;
 using webrtc::PeerConnectionInterface;
 using webrtc::SessionDescriptionInterface;
 using webrtc::SessionStats;
 using webrtc::StreamCollection;
@@ skipping 283 matching lines @@
   void AddInterface(const SocketAddress& addr) {
     network_manager_.AddInterface(addr);
   }
 
   // If |dtls_identity_store| != null or |rtc_configuration| contains
   // |certificates| then DTLS will be enabled unless explicitly disabled by
   // |rtc_configuration| options. When DTLS is enabled a certificate will be
   // used if provided, otherwise one will be generated using the
   // |dtls_identity_store|.
   void Init(
-      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store,
-      const PeerConnectionInterface::RTCConfiguration& rtc_configuration) {
+      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store) {
     ASSERT_TRUE(session_.get() == NULL);
     session_.reset(new WebRtcSessionForTest(
         media_controller_.get(), rtc::Thread::Current(), rtc::Thread::Current(),
         allocator_.get(), &observer_));
     session_->SignalDataChannelOpenMessage.connect(
         this, &WebRtcSessionTest::OnDataChannelOpenMessage);
     session_->GetOnDestroyedSignal()->connect(
         this, &WebRtcSessionTest::OnSessionDestroyed);
 
     EXPECT_EQ(PeerConnectionInterface::kIceConnectionNew,
         observer_.ice_connection_state_);
     EXPECT_EQ(PeerConnectionInterface::kIceGatheringNew,
         observer_.ice_gathering_state_);
 
-    EXPECT_TRUE(session_->Initialize(options_, constraints_.get(),
-                                     std::move(dtls_identity_store),
-                                     rtc_configuration));
+    EXPECT_TRUE(session_->Initialize(options_, std::move(dtls_identity_store),
+                                     configuration_));
     session_->set_metrics_observer(metrics_observer_);
   }
 
   void OnDataChannelOpenMessage(const std::string& label,
                                 const InternalDataChannelInit& config) {
     last_data_channel_label_ = label;
     last_data_channel_config_ = config;
   }
 
   void OnSessionDestroyed() { session_destroyed_ = true; }
 
-  void Init() {
-    PeerConnectionInterface::RTCConfiguration configuration;
-    Init(nullptr, configuration);
-  }
+  void Init() { Init(nullptr); }
 
   void InitWithIceTransport(
       PeerConnectionInterface::IceTransportsType ice_transport_type) {
-    PeerConnectionInterface::RTCConfiguration configuration;
-    configuration.type = ice_transport_type;
-    Init(nullptr, configuration);
+    configuration_.type = ice_transport_type;
+    Init();
   }
 
   void InitWithBundlePolicy(
       PeerConnectionInterface::BundlePolicy bundle_policy) {
-    PeerConnectionInterface::RTCConfiguration configuration;
-    configuration.bundle_policy = bundle_policy;
-    Init(nullptr, configuration);
+    configuration_.bundle_policy = bundle_policy;
+    Init();
   }
 
   void InitWithRtcpMuxPolicy(
       PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy) {
     PeerConnectionInterface::RTCConfiguration configuration;
-    configuration.rtcp_mux_policy = rtcp_mux_policy;
-    Init(nullptr, configuration);
+    configuration_.rtcp_mux_policy = rtcp_mux_policy;
+    Init();
   }
 
   // Successfully init with DTLS; with a certificate generated and supplied or
   // with a store that generates it for us.
   void InitWithDtls(RTCCertificateGenerationMethod cert_gen_method) {
     rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store;
-    PeerConnectionInterface::RTCConfiguration configuration;
     if (cert_gen_method == ALREADY_GENERATED) {
-      configuration.certificates.push_back(
+      configuration_.certificates.push_back(
           FakeDtlsIdentityStore::GenerateCertificate());
     } else if (cert_gen_method == DTLS_IDENTITY_STORE) {
       dtls_identity_store.reset(new FakeDtlsIdentityStore());
       dtls_identity_store->set_should_fail(false);
     } else {
       RTC_CHECK(false);
     }
-    Init(std::move(dtls_identity_store), configuration);
+    Init(std::move(dtls_identity_store));
   }
 
   // Init with DTLS with a store that will fail to generate a certificate.
   void InitWithDtlsIdentityGenFail() {
     rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
         new FakeDtlsIdentityStore());
     dtls_identity_store->set_should_fail(true);
-    PeerConnectionInterface::RTCConfiguration configuration;
-    Init(std::move(dtls_identity_store), configuration);
+    Init(std::move(dtls_identity_store));
   }
 
   void InitWithDtmfCodec() {
     // Add kTelephoneEventCodec for dtmf test.
     const cricket::AudioCodec kTelephoneEventCodec(
         106, "telephone-event", 8000, 0, 1, 0);
     std::vector<cricket::AudioCodec> codecs;
     codecs.push_back(kTelephoneEventCodec);
     media_engine_->SetAudioCodecs(codecs);
     desc_factory_->set_audio_codecs(codecs);
@@ skipping 62 matching lines @@
     if (data_channel_ && session_->data_channel_type() == cricket::DCT_RTP) {
       session_options->AddSendStream(cricket::MEDIA_TYPE_DATA,
                                      data_channel_->label(),
                                      data_channel_->label());
     }
   }
 
   void GetOptionsForOffer(
       const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
       cricket::MediaSessionOptions* session_options) {
-    ASSERT_TRUE(ConvertRtcOptionsForOffer(rtc_options, session_options));
+    ASSERT_TRUE(ExtractMediaSessionOptions(rtc_options, session_options));
 
     AddStreamsToOptions(session_options);
     if (rtc_options.offer_to_receive_audio ==
         RTCOfferAnswerOptions::kUndefined) {
       session_options->recv_audio =
           session_options->HasSendMediaStream(cricket::MEDIA_TYPE_AUDIO);
     }
     if (rtc_options.offer_to_receive_video ==
         RTCOfferAnswerOptions::kUndefined) {
       session_options->recv_video =
           session_options->HasSendMediaStream(cricket::MEDIA_TYPE_VIDEO);
     }
     session_options->bundle_enabled =
         session_options->bundle_enabled &&
         (session_options->has_audio() || session_options->has_video() ||
          session_options->has_data());
 
     if (session_->data_channel_type() == cricket::DCT_SCTP && data_channel_) {
       session_options->data_channel_type = cricket::DCT_SCTP;
     }
   }
 
-  void GetOptionsForAnswer(const webrtc::MediaConstraintsInterface* constraints,
-                           cricket::MediaSessionOptions* session_options) {
-    session_options->recv_audio = false;
-    session_options->recv_video = false;
-    ASSERT_TRUE(ParseConstraintsForAnswer(constraints, session_options));
+  void GetOptionsForAnswer(cricket::MediaSessionOptions* session_options) {
+    // ParseConstraintsForAnswer is used to set some defaults.
+    ASSERT_TRUE(webrtc::ParseConstraintsForAnswer(nullptr, session_options));
 
     AddStreamsToOptions(session_options);
     session_options->bundle_enabled =
         session_options->bundle_enabled &&
         (session_options->has_audio() || session_options->has_video() ||
          session_options->has_data());
 
     if (session_->data_channel_type() == cricket::DCT_SCTP) {
       session_options->data_channel_type = cricket::DCT_SCTP;
     }
@@ skipping 12 matching lines @@
 
   SessionDescriptionInterface* CreateOffer() {
     PeerConnectionInterface::RTCOfferAnswerOptions options;
     options.offer_to_receive_audio =
         RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
 
     return CreateOffer(options);
   }
 
   SessionDescriptionInterface* CreateOffer(
-      const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
+      const PeerConnectionInterface::RTCOfferAnswerOptions options) {
     rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
         observer = new WebRtcSessionCreateSDPObserverForTest();
     cricket::MediaSessionOptions session_options;
     GetOptionsForOffer(options, &session_options);
     session_->CreateOffer(observer, options, session_options);
     EXPECT_TRUE_WAIT(
         observer->state() != WebRtcSessionCreateSDPObserverForTest::kInit,
         2000);
     return observer->ReleaseDescription();
   }
 
   SessionDescriptionInterface* CreateAnswer(
-      const webrtc::MediaConstraintsInterface* constraints) {
+      const cricket::MediaSessionOptions& options) {
     rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observer
         = new WebRtcSessionCreateSDPObserverForTest();
-    cricket::MediaSessionOptions session_options;
-    GetOptionsForAnswer(constraints, &session_options);
-    session_->CreateAnswer(observer, constraints, session_options);
+    cricket::MediaSessionOptions session_options = options;
+    GetOptionsForAnswer(&session_options);
+    // Overwrite recv_audio and recv_video with passed-in values.
+    session_options.recv_video = options.recv_video;
+    session_options.recv_audio = options.recv_audio;
+    session_->CreateAnswer(observer, session_options);
     EXPECT_TRUE_WAIT(
         observer->state() != WebRtcSessionCreateSDPObserverForTest::kInit,
         2000);
     return observer->ReleaseDescription();
   }
 
+  SessionDescriptionInterface* CreateAnswer() {
+    cricket::MediaSessionOptions options;
+    options.recv_video = true;
+    options.recv_audio = true;
+    return CreateAnswer(options);
+  }
+
   bool ChannelsExist() const {
     return (session_->voice_channel() != NULL &&
             session_->video_channel() != NULL);
   }
 
   void VerifyCryptoParams(const cricket::SessionDescription* sdp) {
     ASSERT_TRUE(session_.get() != NULL);
     const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
     ASSERT_TRUE(content != NULL);
     const cricket::AudioContentDescription* audio_content =
@@ skipping 76 matching lines @@
   void VerifyAnswerFromNonCryptoOffer() {
     // Create an SDP without Crypto.
     cricket::MediaSessionOptions options;
     options.recv_video = true;
     JsepSessionDescription* offer(
         CreateRemoteOffer(options, cricket::SEC_DISABLED));
     ASSERT_TRUE(offer != NULL);
     VerifyNoCryptoParams(offer->description(), false);
     SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto,
                                          offer);
-    const webrtc::SessionDescriptionInterface* answer = CreateAnswer(NULL);
+    const webrtc::SessionDescriptionInterface* answer = CreateAnswer();
     // Answer should be NULL as no crypto params in offer.
     ASSERT_TRUE(answer == NULL);
   }
 
   void VerifyAnswerFromCryptoOffer() {
     cricket::MediaSessionOptions options;
     options.recv_video = true;
     options.bundle_enabled = true;
     scoped_ptr<JsepSessionDescription> offer(
         CreateRemoteOffer(options, cricket::SEC_REQUIRED));
     ASSERT_TRUE(offer.get() != NULL);
     VerifyCryptoParams(offer->description());
     SetRemoteDescriptionWithoutError(offer.release());
-    scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(NULL));
+    scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
     ASSERT_TRUE(answer.get() != NULL);
     VerifyCryptoParams(answer->description());
   }
 
   bool IceUfragPwdEqual(const cricket::SessionDescription* desc1,
                         const cricket::SessionDescription* desc2) {
     if (desc1->contents().size() != desc2->contents().size()) {
       return false;
     }
 
@@ skipping 91 matching lines @@
     transport_desc->ice_pwd = pwd;
   }
 
   // Creates a remote offer and and applies it as a remote description,
   // creates a local answer and applies is as a local description.
   // Call SendAudioVideoStreamX() before this function
   // to decide which local and remote streams to create.
   void CreateAndSetRemoteOfferAndLocalAnswer() {
     SessionDescriptionInterface* offer = CreateRemoteOffer();
     SetRemoteDescriptionWithoutError(offer);
-    SessionDescriptionInterface* answer = CreateAnswer(NULL);
+    SessionDescriptionInterface* answer = CreateAnswer();
     SetLocalDescriptionWithoutError(answer);
   }
   void SetLocalDescriptionWithoutError(SessionDescriptionInterface* desc) {
     EXPECT_TRUE(session_->SetLocalDescription(desc, NULL));
     session_->MaybeStartGathering();
   }
   void SetLocalDescriptionExpectState(SessionDescriptionInterface* desc,
                                       WebRtcSession::State expected_state) {
     SetLocalDescriptionWithoutError(desc);
     EXPECT_EQ(expected_state, session_->state());
@@ skipping 154 matching lines @@
         offer_basis->type());
     delete offer_basis;
     offer->Initialize(offer_str, NULL);
     return offer;
   }
 
   // Create a remote offer. Call SendAudioVideoStreamX()
   // before this function to decide which streams to create.
   JsepSessionDescription* CreateRemoteOffer() {
     cricket::MediaSessionOptions options;
-    GetOptionsForAnswer(NULL, &options);
+    GetOptionsForAnswer(&options);
     return CreateRemoteOffer(options, session_->remote_description());
   }
 
   JsepSessionDescription* CreateRemoteAnswer(
       const SessionDescriptionInterface* offer,
       cricket::MediaSessionOptions options,
       cricket::SecurePolicy policy) {
     desc_factory_->set_secure(policy);
     const std::string session_id =
         rtc::ToString(rtc::CreateRandomId64());
@@ skipping 13 matching lines @@
       cricket::MediaSessionOptions options) {
       return CreateRemoteAnswer(offer, options, cricket::SEC_REQUIRED);
   }
 
   // Creates an answer session description.
   // Call SendAudioVideoStreamX() before this function
   // to decide which streams to create.
   JsepSessionDescription* CreateRemoteAnswer(
       const SessionDescriptionInterface* offer) {
     cricket::MediaSessionOptions options;
-    GetOptionsForAnswer(NULL, &options);
+    GetOptionsForAnswer(&options);
     return CreateRemoteAnswer(offer, options, cricket::SEC_REQUIRED);
   }
 
   void TestSessionCandidatesWithBundleRtcpMux(bool bundle, bool rtcp_mux) {
     AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
     Init();
     SendAudioVideoStream1();
 
     PeerConnectionInterface::RTCOfferAnswerOptions options;
     options.use_rtp_mux = bundle;
@@ skipping 266 matching lines @@
     ASSERT(audio_content_desc != NULL);
     for (size_t i = 0; i < audio_content_desc->codecs().size(); ++i) {
       if (audio_content_desc->codecs()[i].name == "CN")
         return false;
     }
     return true;
   }
 
   void CreateDataChannel() {
     webrtc::InternalDataChannelInit dci;
+    ASSERT(session_.get());
     dci.reliable = session_->data_channel_type() == cricket::DCT_SCTP;
     data_channel_ = DataChannel::Create(
         session_.get(), session_->data_channel_type(), "datachannel", dci);
   }
 
   void SetLocalDescriptionWithDataChannel() {
     CreateDataChannel();
     SessionDescriptionInterface* offer = CreateOffer();
     SetLocalDescriptionWithoutError(offer);
   }
@@ skipping 26 matching lines @@
     PeerConnectionInterface::RTCOfferAnswerOptions options;
     cricket::MediaSessionOptions session_options;
     const int kNumber = 3;
     rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
         observers[kNumber];
     for (int i = 0; i < kNumber; ++i) {
       observers[i] = new WebRtcSessionCreateSDPObserverForTest();
       if (type == CreateSessionDescriptionRequest::kOffer) {
         session_->CreateOffer(observers[i], options, session_options);
       } else {
-        session_->CreateAnswer(observers[i], nullptr, session_options);
+        session_->CreateAnswer(observers[i], session_options);
       }
     }
 
     WebRtcSessionCreateSDPObserverForTest::State expected_state =
         success ? WebRtcSessionCreateSDPObserverForTest::kSucceeded :
                   WebRtcSessionCreateSDPObserverForTest::kFailed;
 
     for (int i = 0; i < kNumber; ++i) {
       EXPECT_EQ_WAIT(expected_state, observers[i]->state(), 1000);
       if (success) {
@@ skipping 25 matching lines @@
   rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
   rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
   rtc::scoped_ptr<rtc::FirewallSocketServer> fss_;
   rtc::SocketServerScope ss_scope_;
   rtc::SocketAddress stun_socket_addr_;
   rtc::scoped_ptr<cricket::TestStunServer> stun_server_;
   cricket::TestTurnServer turn_server_;
   rtc::FakeNetworkManager network_manager_;
   rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
   PeerConnectionFactoryInterface::Options options_;
-  rtc::scoped_ptr<FakeConstraints> constraints_;
+  PeerConnectionInterface::RTCConfiguration configuration_;
   rtc::scoped_ptr<WebRtcSessionForTest> session_;
   MockIceObserver observer_;
   cricket::FakeVideoMediaChannel* video_channel_;
   cricket::FakeVoiceMediaChannel* voice_channel_;
   rtc::scoped_refptr<FakeMetricsObserver> metrics_observer_;
   // The following flags affect options created for CreateOffer/CreateAnswer.
   bool send_stream_1_ = false;
   bool send_stream_2_ = false;
   bool send_audio_ = false;
   bool send_video_ = false;
@@ skipping 173 matching lines @@
 // Test receiving offers and creating answers and make sure the
 // media engine creates the expected send and receive streams.
 TEST_F(WebRtcSessionTest, TestReceiveSdesOfferCreateSdesAnswer) {
   Init();
   SendAudioVideoStream2();
   SessionDescriptionInterface* offer = CreateOffer();
   VerifyCryptoParams(offer->description());
   SetRemoteDescriptionWithoutError(offer);
 
   SendAudioVideoStream1();
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   VerifyCryptoParams(answer->description());
   SetLocalDescriptionWithoutError(answer);
 
   const std::string session_id_orig = answer->session_id();
   const std::string session_version_orig = answer->session_version();
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
+  ASSERT_TRUE(video_channel_);
+  ASSERT_TRUE(voice_channel_);
   ASSERT_EQ(1u, video_channel_->recv_streams().size());
   EXPECT_TRUE(kVideoTrack2 == video_channel_->recv_streams()[0].id);
 
   ASSERT_EQ(1u, voice_channel_->recv_streams().size());
   EXPECT_TRUE(kAudioTrack2 == voice_channel_->recv_streams()[0].id);
 
   ASSERT_EQ(1u, video_channel_->send_streams().size());
   EXPECT_TRUE(kVideoTrack1 == video_channel_->send_streams()[0].id);
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_TRUE(kAudioTrack1 == voice_channel_->send_streams()[0].id);
 
   SendAudioVideoStream1And2();
   offer = CreateOffer();
   SetRemoteDescriptionWithoutError(offer);
 
   // Answer by turning off all send streams.
   SendNothing();
-  answer = CreateAnswer(NULL);
+  answer = CreateAnswer();
 
   // Verify the session id is the same and the session version is
   // increased.
   EXPECT_EQ(session_id_orig, answer->session_id());
   EXPECT_LT(rtc::FromString<uint64_t>(session_version_orig),
             rtc::FromString<uint64_t>(answer->session_version()));
   SetLocalDescriptionWithoutError(answer);
 
   ASSERT_EQ(2u, video_channel_->recv_streams().size());
   EXPECT_TRUE(kVideoTrack1 == video_channel_->recv_streams()[0].id);
@@ skipping 107 matching lines @@
   JsepSessionDescription* offer =
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
   ASSERT_TRUE(offer != NULL);
   VerifyFingerprintStatus(offer->description(), true);
   VerifyNoCryptoParams(offer->description(), true);
 
   // SetRemoteDescription will take the ownership of the offer.
   SetRemoteDescriptionWithoutError(offer);
 
   // Verify that we get a crypto fingerprint in the answer.
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   ASSERT_TRUE(answer != NULL);
   VerifyFingerprintStatus(answer->description(), true);
   // Check that we don't have an a=crypto line in the answer.
   VerifyNoCryptoParams(answer->description(), true);
 
   // Now set the local description, which should work, even without a=crypto.
   SetLocalDescriptionWithoutError(answer);
 }
 
 // Test that we set a local offer with a DTLS fingerprint when DTLS is on
@@ skipping 126 matching lines @@
   JsepSessionDescription* offer =
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
   ASSERT_TRUE(offer != NULL);
   VerifyFingerprintStatus(offer->description(), false);
   VerifyNoCryptoParams(offer->description(), false);
 
   // SetRemoteDescription will take the ownership of the offer.
   SetRemoteDescriptionWithoutError(offer);
 
   // Verify that we get a crypto fingerprint in the answer.
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   ASSERT_TRUE(answer != NULL);
   VerifyFingerprintStatus(answer->description(), false);
   // Check that we don't have an a=crypto line in the answer.
   VerifyNoCryptoParams(answer->description(), false);
 
   // Now set the local description, which should work, even without a=crypto.
   SetLocalDescriptionWithoutError(answer);
 }
 
 // Test that we can create and set an answer correctly when different
@@ skipping 23 matching lines @@
       cricket::CONNECTIONROLE_PASSIVE;
   SetRemoteDescriptionWithoutError(answer);
 
   // Now create an offer in the reverse direction, and ensure the initial
   // offerer responds with an answer with correct SSL roles.
   offer = CreateRemoteOfferWithVersion(options, cricket::SEC_DISABLED,
                                        kSessionVersion,
                                        session_->remote_description());
   SetRemoteDescriptionWithoutError(offer);
 
-  answer = CreateAnswer(nullptr);
+  answer = CreateAnswer();
   audio_transport_info = answer->description()->GetTransportInfoByName("audio");
   EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
             audio_transport_info->description.connection_role);
   video_transport_info = answer->description()->GetTransportInfoByName("video");
   EXPECT_EQ(cricket::CONNECTIONROLE_ACTIVE,
             video_transport_info->description.connection_role);
   SetLocalDescriptionWithoutError(answer);
 
   // Lastly, start BUNDLE-ing on "audio", expecting that the "passive" role of
   // audio is transferred over to video in the answer that completes the BUNDLE
   // negotiation.
   options.bundle_enabled = true;
   offer = CreateRemoteOfferWithVersion(options, cricket::SEC_DISABLED,
                                        kSessionVersion,
                                        session_->remote_description());
   SetRemoteDescriptionWithoutError(offer);
-  answer = CreateAnswer(nullptr);
+  answer = CreateAnswer();
   audio_transport_info = answer->description()->GetTransportInfoByName("audio");
   EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
             audio_transport_info->description.connection_role);
   video_transport_info = answer->description()->GetTransportInfoByName("video");
   EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
             video_transport_info->description.connection_role);
   SetLocalDescriptionWithoutError(answer);
 }
 
 TEST_F(WebRtcSessionTest, TestSetLocalOfferTwice) {
@@ skipping 38 matching lines @@
   SetLocalDescriptionOfferExpectError(
       "Called in wrong state: STATE_RECEIVEDOFFER", offer);
 }
 
 TEST_F(WebRtcSessionTest, TestSetLocalPrAnswer) {
   Init();
   SendNothing();
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   SetRemoteDescriptionExpectState(offer, WebRtcSession::STATE_RECEIVEDOFFER);
 
-  JsepSessionDescription* pranswer = static_cast<JsepSessionDescription*>(
-      CreateAnswer(NULL));
+  JsepSessionDescription* pranswer =
+      static_cast<JsepSessionDescription*>(CreateAnswer());
   pranswer->set_type(SessionDescriptionInterface::kPrAnswer);
   SetLocalDescriptionExpectState(pranswer, WebRtcSession::STATE_SENTPRANSWER);
 
   SendAudioVideoStream1();
-  JsepSessionDescription* pranswer2 = static_cast<JsepSessionDescription*>(
-      CreateAnswer(NULL));
+  JsepSessionDescription* pranswer2 =
+      static_cast<JsepSessionDescription*>(CreateAnswer());
   pranswer2->set_type(SessionDescriptionInterface::kPrAnswer);
 
   SetLocalDescriptionExpectState(pranswer2, WebRtcSession::STATE_SENTPRANSWER);
 
   SendAudioVideoStream2();
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   SetLocalDescriptionExpectState(answer, WebRtcSession::STATE_INPROGRESS);
 }
 
 TEST_F(WebRtcSessionTest, TestSetRemotePrAnswer) {
   Init();
   SendNothing();
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionExpectState(offer, WebRtcSession::STATE_SENTOFFER);
 
   JsepSessionDescription* pranswer =
@@ skipping 194 matching lines @@
 
   const SessionDescriptionInterface* remote_desc =
       session_->remote_description();
   ASSERT_TRUE(remote_desc != NULL);
   ASSERT_EQ(2u, remote_desc->number_of_mediasections());
   const IceCandidateCollection* candidates =
       remote_desc->candidates(kMediaContentIndex0);
   ASSERT_EQ(1u, candidates->count());
   EXPECT_EQ(kMediaContentIndex0, candidates->at(0)->sdp_mline_index());
 
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 }
 
 // Test that offers and answers contains ice candidates when Ice candidates have
 // been gathered.
 TEST_F(WebRtcSessionTest, TestSetLocalAndRemoteDescriptionWithCandidates) {
   AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
   Init();
   SendAudioVideoStream1();
   // Ice is started but candidates are not provided until SetLocalDescription
   // is called.
   EXPECT_EQ(0u, observer_.mline_0_candidates_.size());
   EXPECT_EQ(0u, observer_.mline_1_candidates_.size());
   CreateAndSetRemoteOfferAndLocalAnswer();
   // Wait until at least one local candidate has been collected.
   EXPECT_TRUE_WAIT(0u < observer_.mline_0_candidates_.size(),
                    kIceCandidatesTimeout);
 
   rtc::scoped_ptr<SessionDescriptionInterface> local_offer(CreateOffer());
 
   ASSERT_TRUE(local_offer->candidates(kMediaContentIndex0) != NULL);
   EXPECT_LT(0u, local_offer->candidates(kMediaContentIndex0)->count());
 
   SessionDescriptionInterface* remote_offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(remote_offer);
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   ASSERT_TRUE(answer->candidates(kMediaContentIndex0) != NULL);
   EXPECT_LT(0u, answer->candidates(kMediaContentIndex0)->count());
   SetLocalDescriptionWithoutError(answer);
 }
 
 // Verifies TransportProxy and media channels are created with content names
 // present in the SessionDescription.
 TEST_F(WebRtcSessionTest, TestChannelCreationsWithContentNames) {
   Init();
   SendAudioVideoStream1();
@@ skipping 20 matching lines @@
   rtc::replace_substrs(kVideoMid.c_str(), kVideoMid.length(),
                              kVideoMidReplaceStr.c_str(),
                              kVideoMidReplaceStr.length(),
                              &sdp);
 
   SessionDescriptionInterface* modified_offer =
       CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
 
   SetRemoteDescriptionWithoutError(modified_offer);
 
-  SessionDescriptionInterface* answer =
-      CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 
   cricket::TransportChannel* voice_transport_channel =
       session_->voice_rtp_transport_channel();
   EXPECT_TRUE(voice_transport_channel != NULL);
   EXPECT_EQ(voice_transport_channel->transport_name(), "audio_content_name");
   cricket::TransportChannel* video_transport_channel =
       session_->video_rtp_transport_channel();
-  EXPECT_TRUE(video_transport_channel != NULL);
+  ASSERT_TRUE(video_transport_channel != NULL);
   EXPECT_EQ(video_transport_channel->transport_name(), "video_content_name");
   EXPECT_TRUE((video_channel_ = media_engine_->GetVideoChannel(0)) != NULL);
   EXPECT_TRUE((voice_channel_ = media_engine_->GetVoiceChannel(0)) != NULL);
 }
 
 // Test that an offer contains the correct media content descriptions based on
 // the send streams when no constraints have been set.
 TEST_F(WebRtcSessionTest, CreateOfferWithoutConstraintsOrStreams) {
   Init();
   rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer());
@@ skipping 100 matching lines @@
 }
 
 // Test that an answer can not be created if the last remote description is not
 // an offer.
 TEST_F(WebRtcSessionTest, CreateAnswerWithoutAnOffer) {
   Init();
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
   SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
   SetRemoteDescriptionWithoutError(answer);
-  EXPECT_TRUE(CreateAnswer(NULL) == NULL);
+  EXPECT_TRUE(CreateAnswer() == NULL);
 }
 
 // Test that an answer contains the correct media content descriptions when no
 // constraints have been set.
 TEST_F(WebRtcSessionTest, CreateAnswerWithoutConstraintsOrStreams) {
   Init();
   // Create a remote offer with audio and video content.
   rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(
-      CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_FALSE(content->rejected);
 
   content = cricket::GetFirstVideoContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_FALSE(content->rejected);
 }
 
 // Test that an answer contains the correct media content descriptions when no
 // constraints have been set and the offer only contain audio.
 TEST_F(WebRtcSessionTest, CreateAudioAnswerWithoutConstraintsOrStreams) {
   Init();
   // Create a remote offer with audio only.
   cricket::MediaSessionOptions options;
 
   rtc::scoped_ptr<JsepSessionDescription> offer(
       CreateRemoteOffer(options));
   ASSERT_TRUE(cricket::GetFirstVideoContent(offer->description()) == NULL);
   ASSERT_TRUE(cricket::GetFirstAudioContent(offer->description()) != NULL);
 
   SetRemoteDescriptionWithoutError(offer.release());
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(
-      CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_FALSE(content->rejected);
 
   EXPECT_TRUE(cricket::GetFirstVideoContent(answer->description()) == NULL);
 }
 
 // Test that an answer contains the correct media content descriptions when no
 // constraints have been set.
 TEST_F(WebRtcSessionTest, CreateAnswerWithoutConstraints) {
   Init();
   // Create a remote offer with audio and video content.
   rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
   // Test with a stream with tracks.
   SendAudioVideoStream1();
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(
-      CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_FALSE(content->rejected);
 
   content = cricket::GetFirstVideoContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_FALSE(content->rejected);
 }
 
 // Test that an answer contains the correct media content descriptions when
 // constraints have been set but no stream is sent.
 TEST_F(WebRtcSessionTest, CreateAnswerWithConstraintsWithoutStreams) {
   Init();
   // Create a remote offer with audio and video content.
   rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
-  webrtc::FakeConstraints constraints_no_receive;
-  constraints_no_receive.SetMandatoryReceiveAudio(false);
-  constraints_no_receive.SetMandatoryReceiveVideo(false);
+  cricket::MediaSessionOptions session_options;
+  session_options.recv_audio = false;
+  session_options.recv_video = false;
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
+      CreateAnswer(session_options));
 
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(
-      CreateAnswer(&constraints_no_receive));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_TRUE(content->rejected);
 
   content = cricket::GetFirstVideoContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_TRUE(content->rejected);
 }
 
 // Test that an answer contains the correct media content descriptions when
 // constraints have been set and streams are sent.
 TEST_F(WebRtcSessionTest, CreateAnswerWithConstraints) {
   Init();
   // Create a remote offer with audio and video content.
   rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
-  webrtc::FakeConstraints constraints_no_receive;
-  constraints_no_receive.SetMandatoryReceiveAudio(false);
-  constraints_no_receive.SetMandatoryReceiveVideo(false);
+  cricket::MediaSessionOptions options;
+  options.recv_audio = false;
+  options.recv_video = false;
 
   // Test with a stream with tracks.
   SendAudioVideoStream1();
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(
-      CreateAnswer(&constraints_no_receive));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(options));
 
   // TODO(perkj): Should the direction be set to SEND_ONLY?
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_FALSE(content->rejected);
 
   // TODO(perkj): Should the direction be set to SEND_ONLY?
   content = cricket::GetFirstVideoContent(answer->description());
   ASSERT_TRUE(content != NULL);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(VerifyNoCNCodecs(content));
 }
 
 TEST_F(WebRtcSessionTest, CreateAnswerWithoutCNCodecs) {
   AddCNCodecs();
   Init();
   // Create a remote offer with audio and video content.
   rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
-  webrtc::FakeConstraints constraints;
-  constraints.SetOptionalVAD(false);
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(
-      CreateAnswer(&constraints));
+  cricket::MediaSessionOptions options;
+  options.vad_enabled = false;
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(options));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_TRUE(VerifyNoCNCodecs(content));
 }
 
 // This test verifies the call setup when remote answer with audio only and
 // later updates with video.
 TEST_F(WebRtcSessionTest, TestAVOfferWithAudioOnlyAnswer) {
   Init();
@@ skipping 104 matching lines @@
   ASSERT_EQ(1u, video_channel_->send_streams().size());
   EXPECT_EQ(kVideoTrack2, video_channel_->send_streams()[0].id);
 }
 
 TEST_F(WebRtcSessionTest, VerifyCryptoParamsInSDP) {
   Init();
   SendAudioVideoStream1();
   scoped_ptr<SessionDescriptionInterface> offer(CreateOffer());
   VerifyCryptoParams(offer->description());
   SetRemoteDescriptionWithoutError(offer.release());
-  scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(NULL));
+  scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   VerifyCryptoParams(answer->description());
 }
 
 TEST_F(WebRtcSessionTest, VerifyNoCryptoParamsInSDP) {
   options_.disable_encryption = true;
   Init();
   SendAudioVideoStream1();
   scoped_ptr<SessionDescriptionInterface> offer(CreateOffer());
   VerifyNoCryptoParams(offer->description(), false);
 }
@@ skipping 167 matching lines @@
 
   InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyBalanced);
   SendAudioVideoStream1();
 
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.use_rtp_mux = true;
 
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   SetRemoteDescriptionWithoutError(offer);
 
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 
   EXPECT_EQ(session_->voice_rtp_transport_channel(),
             session_->video_rtp_transport_channel());
 
   cricket::BaseChannel* voice_channel = session_->voice_channel();
   ASSERT(voice_channel != NULL);
 
   // Checks if one of the transport channels contains a connection using a given
   // port.
@@ skipping 202 matching lines @@
   InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxBundle);
   SendAudioVideoStream1();
 
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   SetRemoteDescriptionWithoutError(offer);
 
   EXPECT_EQ(session_->voice_rtp_transport_channel(),
             session_->video_rtp_transport_channel());
 
   SendAudioVideoStream2();
-  SessionDescriptionInterface* answer = CreateAnswer(nullptr);
+  SessionDescriptionInterface* answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 
   EXPECT_EQ(session_->voice_rtp_transport_channel(),
             session_->video_rtp_transport_channel());
 }
 
 // kBundlePolicyMaxBundle policy but no BUNDLE in the remote offer.
 TEST_F(WebRtcSessionTest, TestMaxBundleNoBundleInRemoteOffer) {
   InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxBundle);
   SendAudioVideoStream1();
@@ skipping 296 matching lines @@
   SetRemoteDescriptionWithoutError(answer);
   EXPECT_TRUE(session_->initial_offerer());
 }
 
 // This test verifies the |initial_offerer| flag when session receives the call.
 TEST_F(WebRtcSessionTest, TestInitiatorFlagAsReceiver) {
   Init();
   EXPECT_FALSE(session_->initial_offerer());
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   SetRemoteDescriptionWithoutError(offer);
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
 
   EXPECT_FALSE(session_->initial_offerer());
   SetLocalDescriptionWithoutError(answer);
   EXPECT_FALSE(session_->initial_offerer());
 }
 
 // Verifing local offer and remote answer have matching m-lines as per RFC 3264.
 TEST_F(WebRtcSessionTest, TestIncorrectMLinesInRemoteAnswer) {
   Init();
   SendAudioVideoStream1();
@@ skipping 40 matching lines @@
   SetRemoteDescriptionWithoutError(answer.release());
 }
 
 // Verifying remote offer and local answer have matching m-lines as per
 // RFC 3264.
 TEST_F(WebRtcSessionTest, TestIncorrectMLinesInLocalAnswer) {
   Init();
   SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   SetRemoteDescriptionWithoutError(offer);
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
 
   cricket::SessionDescription* answer_copy = answer->description()->Copy();
   answer_copy->RemoveContentByName("video");
   JsepSessionDescription* modified_answer =
       new JsepSessionDescription(JsepSessionDescription::kAnswer);
 
   EXPECT_TRUE(modified_answer->Initialize(answer_copy,
                                           answer->session_id(),
                                           answer->session_version()));
   SetLocalDescriptionAnswerExpectError(kMlineMismatch, modified_answer);
@@ skipping 18 matching lines @@
   EXPECT_TRUE(offer->AddCandidate(&ice_candidate1));
   SetRemoteDescriptionWithoutError(offer);
   ASSERT_TRUE(session_->voice_rtp_transport_channel() != NULL);
   ASSERT_TRUE(session_->video_rtp_transport_channel() != NULL);
 
   // Pump for 1 second and verify that no candidates are generated.
   rtc::Thread::Current()->ProcessMessages(1000);
   EXPECT_TRUE(observer_.mline_0_candidates_.empty());
   EXPECT_TRUE(observer_.mline_1_candidates_.empty());
 
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
   EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
 }
 
 // This test verifies that crypto parameter is updated in local session
 // description as per security policy set in MediaSessionDescriptionFactory.
 TEST_F(WebRtcSessionTest, TestCryptoAfterSetLocalDescription) {
   Init();
   SendAudioVideoStream1();
   rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer());
@@ skipping 33 matching lines @@
 // with new ufrag and password is received.
 TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewUfragAndPassword) {
   Init();
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   rtc::scoped_ptr<JsepSessionDescription> offer(
       CreateRemoteOffer(options));
   SetRemoteDescriptionWithoutError(offer.release());
 
   SendAudioVideoStream1();
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(
-      CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer with new ufrag and password.
   for (const cricket::ContentInfo& content :
        session_->local_description()->description()->contents()) {
     options.transport_options[content.name].ice_restart = true;
   }
   rtc::scoped_ptr<JsepSessionDescription> updated_offer1(
       CreateRemoteOffer(options, session_->remote_description()));
   SetRemoteDescriptionWithoutError(updated_offer1.release());
 
-  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer1(
-      CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer1(CreateAnswer());
 
   EXPECT_FALSE(IceUfragPwdEqual(updated_answer1->description(),
                                 session_->local_description()->description()));
 
   // Even a second answer (created before the description is set) should have
   // a new ufrag/password.
-  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer2(
-      CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer2(CreateAnswer());
 
   EXPECT_FALSE(IceUfragPwdEqual(updated_answer2->description(),
                                 session_->local_description()->description()));
 
   SetLocalDescriptionWithoutError(updated_answer2.release());
 }
 
 // This test verifies that an answer contains new ufrag and password if an offer
 // that changes either the ufrag or password (but not both) is received.
 // RFC 5245 says: "If the offer contained a change in the a=ice-ufrag or
 // a=ice-pwd attributes compared to the previous SDP from the peer, it
 // indicates that ICE is restarting for this media stream."
 TEST_F(WebRtcSessionTest, TestOfferChangingOnlyUfragOrPassword) {
   Init();
   cricket::MediaSessionOptions options;
   options.recv_audio = true;
   options.recv_video = true;
   // Create an offer with audio and video.
   rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
   SetIceUfragPwd(offer.get(), "original_ufrag", "original_password12345");
   SetRemoteDescriptionWithoutError(offer.release());
 
   SendAudioVideoStream1();
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(nullptr));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer with a new ufrag but stale password.
   rtc::scoped_ptr<JsepSessionDescription> ufrag_changed_offer(
       CreateRemoteOffer(options, session_->remote_description()));
   SetIceUfragPwd(ufrag_changed_offer.get(), "modified_ufrag",
                  "original_password12345");
   SetRemoteDescriptionWithoutError(ufrag_changed_offer.release());
 
-  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer1(
-      CreateAnswer(nullptr));
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer1(CreateAnswer());
   EXPECT_FALSE(IceUfragPwdEqual(updated_answer1->description(),
                                 session_->local_description()->description()));
   SetLocalDescriptionWithoutError(updated_answer1.release());
 
   // Receive an offer with a new password but stale ufrag.
   rtc::scoped_ptr<JsepSessionDescription> password_changed_offer(
       CreateRemoteOffer(options, session_->remote_description()));
   SetIceUfragPwd(password_changed_offer.get(), "modified_ufrag",
                  "modified_password12345");
   SetRemoteDescriptionWithoutError(password_changed_offer.release());
 
-  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer2(
-      CreateAnswer(nullptr));
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer2(CreateAnswer());
   EXPECT_FALSE(IceUfragPwdEqual(updated_answer2->description(),
                                 session_->local_description()->description()));
   SetLocalDescriptionWithoutError(updated_answer2.release());
 }
 
 // This test verifies that an answer contains old ufrag and password if an offer
 // with old ufrag and password is received.
 TEST_F(WebRtcSessionTest, TestCreateAnswerWithOldUfragAndPassword) {
   Init();
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   rtc::scoped_ptr<JsepSessionDescription> offer(
       CreateRemoteOffer(options));
   SetRemoteDescriptionWithoutError(offer.release());
 
   SendAudioVideoStream1();
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(
-      CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer without changed ufrag or password.
   rtc::scoped_ptr<JsepSessionDescription> updated_offer2(
       CreateRemoteOffer(options, session_->remote_description()));
   SetRemoteDescriptionWithoutError(updated_offer2.release());
 
-  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer2(
-      CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer2(CreateAnswer());
 
   EXPECT_TRUE(IceUfragPwdEqual(updated_answer2->description(),
                                session_->local_description()->description()));
 
   SetLocalDescriptionWithoutError(updated_answer2.release());
 }
 
 // This test verifies that if an offer does an ICE restart on some, but not all
 // media sections, the answer will change the ufrag/password in the correct
 // media sections.
 TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewAndOldUfragAndPassword) {
   Init();
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   options.recv_audio = true;
   options.bundle_enabled = false;
   rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
 
   SetIceUfragPwd(offer.get(), cricket::MEDIA_TYPE_AUDIO, "aaaa",
                  "aaaaaaaaaaaaaaaaaaaaaa");
   SetIceUfragPwd(offer.get(), cricket::MEDIA_TYPE_VIDEO, "bbbb",
                  "bbbbbbbbbbbbbbbbbbbbbb");
   SetRemoteDescriptionWithoutError(offer.release());
 
   SendAudioVideoStream1();
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(nullptr));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer with new ufrag and password, but only for the video media
   // section.
   rtc::scoped_ptr<JsepSessionDescription> updated_offer(
       CreateRemoteOffer(options, session_->remote_description()));
   SetIceUfragPwd(updated_offer.get(), cricket::MEDIA_TYPE_VIDEO, "cccc",
                  "cccccccccccccccccccccc");
   SetRemoteDescriptionWithoutError(updated_offer.release());
 
-  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer(
-      CreateAnswer(nullptr));
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer(CreateAnswer());
 
   EXPECT_TRUE(IceUfragPwdEqual(updated_answer->description(),
                                session_->local_description()->description(),
                                cricket::MEDIA_TYPE_AUDIO));
 
   EXPECT_FALSE(IceUfragPwdEqual(updated_answer->description(),
                                 session_->local_description()->description(),
                                 cricket::MEDIA_TYPE_VIDEO));
 
   SetLocalDescriptionWithoutError(updated_answer.release());
@@ skipping 48 matching lines @@
 }
 
 // Runs the loopback call test with BUNDLE and STUN enabled.
 TEST_F(WebRtcSessionTest, TestIceStatesBundle) {
   allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
                         cricket::PORTALLOCATOR_DISABLE_RELAY);
   TestLoopbackCall();
 }
 
 TEST_F(WebRtcSessionTest, TestRtpDataChannel) {
-  constraints_.reset(new FakeConstraints());
-  constraints_->AddOptional(
-      webrtc::MediaConstraintsInterface::kEnableRtpDataChannels, true);
+  configuration_.enable_rtp_data_channel = true;
   Init();
-
   SetLocalDescriptionWithDataChannel();
+  ASSERT_TRUE(data_engine_);
   EXPECT_EQ(cricket::DCT_RTP, data_engine_->last_channel_type());
 }
 
 TEST_P(WebRtcSessionTest, TestRtpDataChannelConstraintTakesPrecedence) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
-  constraints_.reset(new FakeConstraints());
-  constraints_->AddOptional(
-      webrtc::MediaConstraintsInterface::kEnableRtpDataChannels, true);
+  configuration_.enable_rtp_data_channel = true;
   options_.disable_sctp_data_channels = false;
 
   InitWithDtls(GetParam());
 
   SetLocalDescriptionWithDataChannel();
   EXPECT_EQ(cricket::DCT_RTP, data_engine_->last_channel_type());
 }
 
 TEST_P(WebRtcSessionTest, TestCreateOfferWithSctpEnabledWithoutStreams) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
@@ skipping 11 matching lines @@
   InitWithDtls(GetParam());
 
   // Create remote offer with SCTP.
   cricket::MediaSessionOptions options;
   options.data_channel_type = cricket::DCT_SCTP;
   JsepSessionDescription* offer =
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
   SetRemoteDescriptionWithoutError(offer);
 
   // Verifies the answer contains SCTP.
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   EXPECT_TRUE(answer != NULL);
   EXPECT_TRUE(answer->description()->GetContentByName("data") != NULL);
   EXPECT_TRUE(answer->description()->GetTransportInfoByName("data") != NULL);
 }
 
 TEST_P(WebRtcSessionTest, TestSctpDataChannelWithoutDtls) {
-  constraints_.reset(new FakeConstraints());
-  constraints_->AddOptional(
-      webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, false);
+  configuration_.enable_dtls_srtp = rtc::Optional<bool>(false);
   InitWithDtls(GetParam());
 
   SetLocalDescriptionWithDataChannel();
   EXPECT_EQ(cricket::DCT_NONE, data_engine_->last_channel_type());
 }
 
 TEST_P(WebRtcSessionTest, TestSctpDataChannelWithDtls) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   InitWithDtls(GetParam());
@@ skipping 23 matching lines @@
   // actually get serialized for SCTP in BuildMediaDescription().  Instead,
   // let the session description get parsed.  That'll get the proper codecs
   // into the stream.
   cricket::MediaSessionOptions options;
   JsepSessionDescription* offer = CreateRemoteOfferWithSctpPort(
       "stream1", new_send_port, options);
 
   // SetRemoteDescription will take the ownership of the offer.
   SetRemoteDescriptionWithoutError(offer);
 
-  SessionDescriptionInterface* answer = ChangeSDPSctpPort(
-      new_recv_port, CreateAnswer(NULL));
+  SessionDescriptionInterface* answer =
+      ChangeSDPSctpPort(new_recv_port, CreateAnswer());
   ASSERT_TRUE(answer != NULL);
 
   // Now set the local description, which'll take ownership of the answer.
   SetLocalDescriptionWithoutError(answer);
 
   // TEST PLAN: Set the port number to something new, set it in the SDP,
   // and pass it all the way down.
   EXPECT_EQ(cricket::DCT_SCTP, data_engine_->last_channel_type());
   CreateDataChannel();
 
@@ skipping 43 matching lines @@
   EXPECT_EQ(config.id, last_data_channel_config_.id);
   EXPECT_FALSE(last_data_channel_config_.negotiated);
   EXPECT_EQ(webrtc::InternalDataChannelInit::kAcker,
             last_data_channel_config_.open_handshake_role);
 }
 
 TEST_P(WebRtcSessionTest, TestUsesProvidedCertificate) {
   rtc::scoped_refptr<rtc::RTCCertificate> certificate =
       FakeDtlsIdentityStore::GenerateCertificate();
 
-  PeerConnectionInterface::RTCConfiguration configuration;
-  configuration.certificates.push_back(certificate);
-  Init(nullptr, configuration);
+  configuration_.certificates.push_back(certificate);
+  Init();
   EXPECT_TRUE_WAIT(!session_->waiting_for_certificate_for_testing(), 1000);
 
   EXPECT_EQ(session_->certificate_for_testing(), certificate);
 }
 
 // Verifies that CreateOffer succeeds when CreateOffer is called before async
 // identity generation is finished (even if a certificate is provided this is
 // an async op).
 TEST_P(WebRtcSessionTest, TestCreateOfferBeforeIdentityRequestReturnSuccess) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
@@ skipping 16 matching lines @@
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   scoped_ptr<JsepSessionDescription> offer(
         CreateRemoteOffer(options, cricket::SEC_DISABLED));
   ASSERT_TRUE(offer.get() != NULL);
   SetRemoteDescriptionWithoutError(offer.release());
 
-  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   EXPECT_TRUE(answer != NULL);
   VerifyNoCryptoParams(answer->description(), true);
   VerifyFingerprintStatus(answer->description(), true);
 }
 
 // Verifies that CreateOffer succeeds when CreateOffer is called after async
 // identity generation is finished (even if a certificate is provided this is
 // an async op).
 TEST_P(WebRtcSessionTest, TestCreateOfferAfterIdentityRequestReturnSuccess) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
@@ skipping 68 matching lines @@
   ASSERT_TRUE(audio != NULL);
   ASSERT_TRUE(audio->description.identity_fingerprint.get() == NULL);
   audio->description.identity_fingerprint.reset(
       rtc::SSLFingerprint::CreateFromRfc4572(
           rtc::DIGEST_SHA_256, kFakeDtlsFingerprint));
   SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto,
                                        offer);
 }
 
 TEST_F(WebRtcSessionTest, TestCombinedAudioVideoBweConstraint) {
-  constraints_.reset(new FakeConstraints());
-  constraints_->AddOptional(
-      webrtc::MediaConstraintsInterface::kCombinedAudioVideoBwe,
-      true);
+  configuration_.combined_audio_video_bwe = rtc::Optional<bool>(true);
   Init();
   SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
 
   SetLocalDescriptionWithoutError(offer);
 
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
   ASSERT_TRUE(voice_channel_ != NULL);
   const cricket::AudioOptions& audio_options = voice_channel_->options();
@@ skipping 19 matching lines @@
   offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
 
   cricket::Candidate candidate1;
   candidate1.set_address(rtc::SocketAddress("1.1.1.1", 5000));
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate(kMediaContentName1, kMediaContentIndex1,
                                  candidate1);
   EXPECT_TRUE(offer->AddCandidate(&ice_candidate));
   SetRemoteDescriptionWithoutError(offer);
 
-  answer = CreateAnswer(NULL);
+  answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 }
 
 // Tests that we can renegotiate new media content with ICE candidates separated
 // from the remote SDP.
 TEST_P(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesSeparated) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
   SendAudioOnlyStream2();
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
 
   SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
   SetRemoteDescriptionWithoutError(answer);
 
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
   SetRemoteDescriptionWithoutError(offer);
 
   cricket::Candidate candidate1;
   candidate1.set_address(rtc::SocketAddress("1.1.1.1", 5000));
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate(kMediaContentName1, kMediaContentIndex1,
                                  candidate1);
   EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate));
 
-  answer = CreateAnswer(NULL);
+  answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 }
 
 // Flaky on Win and Mac only. See webrtc:4943
 #if defined(WEBRTC_WIN) || defined(WEBRTC_MAC)
 #define MAYBE_TestRtxRemovedByCreateAnswer DISABLED_TestRtxRemovedByCreateAnswer
 #else
 #define MAYBE_TestRtxRemovedByCreateAnswer TestRtxRemovedByCreateAnswer
 #endif
 // Tests that RTX codec is removed from the answer when it isn't supported
 // by local side.
 TEST_F(WebRtcSessionTest, MAYBE_TestRtxRemovedByCreateAnswer) {
   Init();
   SendAudioVideoStream1();
   std::string offer_sdp(kSdpWithRtx);
 
   SessionDescriptionInterface* offer =
       CreateSessionDescription(JsepSessionDescription::kOffer, offer_sdp, NULL);
   EXPECT_TRUE(offer->ToString(&offer_sdp));
 
   // Offer SDP contains the RTX codec.
   EXPECT_TRUE(offer_sdp.find("rtx") != std::string::npos);
   SetRemoteDescriptionWithoutError(offer);
 
-  SessionDescriptionInterface* answer = CreateAnswer(NULL);
+  SessionDescriptionInterface* answer = CreateAnswer();
   std::string answer_sdp;
   answer->ToString(&answer_sdp);
   // Answer SDP removes the unsupported RTX codec.
   EXPECT_TRUE(answer_sdp.find("rtx") == std::string::npos);
   SetLocalDescriptionWithoutError(answer);
 }
 
 // This verifies that the voice channel after bundle has both options from video
 // and voice channels.
 TEST_F(WebRtcSessionTest, TestSetSocketOptionBeforeBundle) {
@@ skipping 84 matching lines @@
 }
 
 // TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled.  That test
 // currently fails because upon disconnection and reconnection OnIceComplete is
 // called more than once without returning to IceGatheringGathering.
 
 INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
                         WebRtcSessionTest,
                         testing::Values(ALREADY_GENERATED,
                                         DTLS_IDENTITY_STORE));