Replace NULL with nullptr in all C++ files.

webrtc/pc/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.
  */
 
@@ skipping 328 matching lines @@
  protected:
   ~WebRtcSessionCreateSDPObserverForTest() {}
 
  private:
   std::unique_ptr<SessionDescriptionInterface> description_;
   State state_;
 };
 
 class FakeAudioSource : public cricket::AudioSource {
  public:
-  FakeAudioSource() : sink_(NULL) {}
+  FakeAudioSource() : sink_(nullptr) {}
   virtual ~FakeAudioSource() {
     if (sink_)
       sink_->OnClose();
   }
 
   void SetSink(Sink* sink) override { sink_ = sink; }
 
   const cricket::AudioSource::Sink* sink() const { return sink_; }
 
  private:
@@ skipping 52 matching lines @@
     network_manager_.RemoveInterface(addr);
   }
 
   // If |cert_generator| != 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 |cert_generator|.
   void Init(
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
       PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy) {
-    ASSERT_TRUE(session_.get() == NULL);
+    ASSERT_TRUE(session_.get() == nullptr);
     fake_sctp_transport_factory_ = new FakeSctpTransportFactory();
     session_.reset(new WebRtcSessionForTest(
         media_controller_.get(), rtc::Thread::Current(), rtc::Thread::Current(),
         rtc::Thread::Current(), allocator_.get(), &observer_,
         std::unique_ptr<cricket::TransportController>(
             new cricket::TransportController(rtc::Thread::Current(),
                                              rtc::Thread::Current(),
                                              allocator_.get())),
         std::unique_ptr<FakeSctpTransportFactory>(
             fake_sctp_transport_factory_)));
@@ skipping 237 matching lines @@
   }
 
   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);
+    return (session_->voice_channel() != nullptr &&
+            session_->video_channel() != nullptr);
   }
 
   void VerifyCryptoParams(const cricket::SessionDescription* sdp,
       bool gcm_enabled = false) {
-    ASSERT_TRUE(session_.get() != NULL);
+    ASSERT_TRUE(session_.get() != nullptr);
     const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
-    ASSERT_TRUE(content != NULL);
+    ASSERT_TRUE(content != nullptr);
     const cricket::AudioContentDescription* audio_content =
         static_cast<const cricket::AudioContentDescription*>(
             content->description);
-    ASSERT_TRUE(audio_content != NULL);
+    ASSERT_TRUE(audio_content != nullptr);
     if (!gcm_enabled) {
       ASSERT_EQ(1U, audio_content->cryptos().size());
       ASSERT_EQ(47U, audio_content->cryptos()[0].key_params.size());
       ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
                 audio_content->cryptos()[0].cipher_suite);
       EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
                 audio_content->protocol());
     } else {
       // The offer contains 3 possible crypto suites, the answer 1.
       EXPECT_LE(1U, audio_content->cryptos().size());
       EXPECT_NE(2U, audio_content->cryptos().size());
       EXPECT_GE(3U, audio_content->cryptos().size());
       ASSERT_EQ(67U, audio_content->cryptos()[0].key_params.size());
       ASSERT_EQ("AEAD_AES_256_GCM",
                 audio_content->cryptos()[0].cipher_suite);
       EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
                 audio_content->protocol());
     }
 
     content = cricket::GetFirstVideoContent(sdp);
-    ASSERT_TRUE(content != NULL);
+    ASSERT_TRUE(content != nullptr);
     const cricket::VideoContentDescription* video_content =
         static_cast<const cricket::VideoContentDescription*>(
             content->description);
-    ASSERT_TRUE(video_content != NULL);
+    ASSERT_TRUE(video_content != nullptr);
     if (!gcm_enabled) {
       ASSERT_EQ(1U, video_content->cryptos().size());
       ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
                 video_content->cryptos()[0].cipher_suite);
       ASSERT_EQ(47U, video_content->cryptos()[0].key_params.size());
       EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
                 video_content->protocol());
     } else {
       // The offer contains 3 possible crypto suites, the answer 1.
       EXPECT_LE(1U, video_content->cryptos().size());
       EXPECT_NE(2U, video_content->cryptos().size());
       EXPECT_GE(3U, video_content->cryptos().size());
       ASSERT_EQ("AEAD_AES_256_GCM",
                 video_content->cryptos()[0].cipher_suite);
       ASSERT_EQ(67U, video_content->cryptos()[0].key_params.size());
       EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
                 video_content->protocol());
     }
   }
 
   void VerifyNoCryptoParams(const cricket::SessionDescription* sdp, bool dtls) {
     const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
-    ASSERT_TRUE(content != NULL);
+    ASSERT_TRUE(content != nullptr);
     const cricket::AudioContentDescription* audio_content =
         static_cast<const cricket::AudioContentDescription*>(
             content->description);
-    ASSERT_TRUE(audio_content != NULL);
+    ASSERT_TRUE(audio_content != nullptr);
     ASSERT_EQ(0U, audio_content->cryptos().size());
 
     content = cricket::GetFirstVideoContent(sdp);
-    ASSERT_TRUE(content != NULL);
+    ASSERT_TRUE(content != nullptr);
     const cricket::VideoContentDescription* video_content =
         static_cast<const cricket::VideoContentDescription*>(
             content->description);
-    ASSERT_TRUE(video_content != NULL);
+    ASSERT_TRUE(video_content != nullptr);
     ASSERT_EQ(0U, video_content->cryptos().size());
 
     if (dtls) {
       EXPECT_EQ(std::string(cricket::kMediaProtocolDtlsSavpf),
                 audio_content->protocol());
       EXPECT_EQ(std::string(cricket::kMediaProtocolDtlsSavpf),
                 video_content->protocol());
     } else {
       EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf),
                 audio_content->protocol());
@@ skipping 10 matching lines @@
     // Confirmed to work with KT_RSA and KT_ECDSA.
     tdesc_factory_->set_certificate(
         rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(identity_name, rtc::KT_DEFAULT))));
     tdesc_factory_->set_secure(cricket::SEC_REQUIRED);
   }
 
   void VerifyFingerprintStatus(const cricket::SessionDescription* sdp,
                                bool expected) {
     const TransportInfo* audio = sdp->GetTransportInfoByName("audio");
-    ASSERT_TRUE(audio != NULL);
-    ASSERT_EQ(expected, audio->description.identity_fingerprint.get() != NULL);
+    ASSERT_TRUE(audio != nullptr);
+    ASSERT_EQ(expected,
+              audio->description.identity_fingerprint.get() != nullptr);
     const TransportInfo* video = sdp->GetTransportInfoByName("video");
-    ASSERT_TRUE(video != NULL);
-    ASSERT_EQ(expected, video->description.identity_fingerprint.get() != NULL);
+    ASSERT_TRUE(video != nullptr);
+    ASSERT_EQ(expected,
+              video->description.identity_fingerprint.get() != nullptr);
   }
 
   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);
+    ASSERT_TRUE(offer != nullptr);
     VerifyNoCryptoParams(offer->description(), false);
     SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto,
                                          offer);
     const webrtc::SessionDescriptionInterface* answer = CreateAnswer();
-    // Answer should be NULL as no crypto params in offer.
-    ASSERT_TRUE(answer == NULL);
+    // Answer should be null as no crypto params in offer.
+    ASSERT_TRUE(answer == nullptr);
   }
 
   void VerifyAnswerFromCryptoOffer() {
     cricket::MediaSessionOptions options;
     options.recv_video = true;
     options.bundle_enabled = true;
     std::unique_ptr<JsepSessionDescription> offer(
         CreateRemoteOffer(options, cricket::SEC_REQUIRED));
-    ASSERT_TRUE(offer.get() != NULL);
+    ASSERT_TRUE(offer.get() != nullptr);
     VerifyCryptoParams(offer->description());
     SetRemoteDescriptionWithoutError(offer.release());
     std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
-    ASSERT_TRUE(answer.get() != NULL);
+    ASSERT_TRUE(answer.get() != nullptr);
     VerifyCryptoParams(answer->description());
   }
 
   bool IceUfragPwdEqual(const cricket::SessionDescription* desc1,
                         const cricket::SessionDescription* desc2) {
     if (desc1->contents().size() != desc2->contents().size()) {
       return false;
     }
 
     const cricket::ContentInfos& contents = desc1->contents();
@@ skipping 94 matching lines @@
   // 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();
     SetLocalDescriptionWithoutError(answer);
   }
   void SetLocalDescriptionWithoutError(SessionDescriptionInterface* desc) {
-    EXPECT_TRUE(session_->SetLocalDescription(desc, NULL));
+    EXPECT_TRUE(session_->SetLocalDescription(desc, nullptr));
     session_->MaybeStartGathering();
   }
   void SetLocalDescriptionExpectState(SessionDescriptionInterface* desc,
                                       WebRtcSession::State expected_state) {
     SetLocalDescriptionWithoutError(desc);
     EXPECT_EQ(expected_state, session_->state());
   }
   void SetLocalDescriptionExpectError(const std::string& action,
                                       const std::string& expected_error,
                                       SessionDescriptionInterface* desc) {
     std::string error;
     EXPECT_FALSE(session_->SetLocalDescription(desc, &error));
     std::string sdp_type = "local ";
     sdp_type.append(action);
     EXPECT_NE(std::string::npos, error.find(sdp_type));
     EXPECT_NE(std::string::npos, error.find(expected_error));
   }
   void SetLocalDescriptionOfferExpectError(const std::string& expected_error,
                                            SessionDescriptionInterface* desc) {
     SetLocalDescriptionExpectError(SessionDescriptionInterface::kOffer,
                                    expected_error, desc);
   }
   void SetLocalDescriptionAnswerExpectError(const std::string& expected_error,
                                             SessionDescriptionInterface* desc) {
     SetLocalDescriptionExpectError(SessionDescriptionInterface::kAnswer,
                                    expected_error, desc);
   }
   void SetRemoteDescriptionWithoutError(SessionDescriptionInterface* desc) {
-    EXPECT_TRUE(session_->SetRemoteDescription(desc, NULL));
+    EXPECT_TRUE(session_->SetRemoteDescription(desc, nullptr));
   }
   void SetRemoteDescriptionExpectState(SessionDescriptionInterface* desc,
                                        WebRtcSession::State expected_state) {
     SetRemoteDescriptionWithoutError(desc);
     EXPECT_EQ(expected_state, session_->state());
   }
   void SetRemoteDescriptionExpectError(const std::string& action,
                                        const std::string& expected_error,
                                        SessionDescriptionInterface* desc) {
     std::string error;
@@ skipping 19 matching lines @@
                                     expected_error, desc);
   }
 
   void CreateCryptoOfferAndNonCryptoAnswer(SessionDescriptionInterface** offer,
       SessionDescriptionInterface** nocrypto_answer) {
     // Create a SDP without Crypto.
     cricket::MediaSessionOptions options;
     options.recv_video = true;
     options.bundle_enabled = true;
     *offer = CreateRemoteOffer(options, cricket::SEC_ENABLED);
-    ASSERT_TRUE(*offer != NULL);
+    ASSERT_TRUE(*offer != nullptr);
     VerifyCryptoParams((*offer)->description());
 
     *nocrypto_answer = CreateRemoteAnswer(*offer, options,
                                           cricket::SEC_DISABLED);
-    EXPECT_TRUE(*nocrypto_answer != NULL);
+    EXPECT_TRUE(*nocrypto_answer != nullptr);
   }
 
   void CreateDtlsOfferAndNonDtlsAnswer(SessionDescriptionInterface** offer,
       SessionDescriptionInterface** nodtls_answer) {
     cricket::MediaSessionOptions options;
     options.recv_video = true;
     options.bundle_enabled = true;
 
     std::unique_ptr<SessionDescriptionInterface> temp_offer(
         CreateRemoteOffer(options, cricket::SEC_ENABLED));
 
     *nodtls_answer =
         CreateRemoteAnswer(temp_offer.get(), options, cricket::SEC_ENABLED);
-    EXPECT_TRUE(*nodtls_answer != NULL);
+    EXPECT_TRUE(*nodtls_answer != nullptr);
     VerifyFingerprintStatus((*nodtls_answer)->description(), false);
     VerifyCryptoParams((*nodtls_answer)->description());
 
     SetFactoryDtlsSrtp();
     *offer = CreateRemoteOffer(options, cricket::SEC_ENABLED);
-    ASSERT_TRUE(*offer != NULL);
+    ASSERT_TRUE(*offer != nullptr);
     VerifyFingerprintStatus((*offer)->description(), true);
     VerifyCryptoParams((*offer)->description());
   }
 
   JsepSessionDescription* CreateRemoteOfferWithVersion(
         cricket::MediaSessionOptions options,
         cricket::SecurePolicy secure_policy,
         const std::string& session_version,
         const SessionDescriptionInterface* current_desc) {
     std::string session_id = rtc::ToString(rtc::CreateRandomId64());
-    const cricket::SessionDescription* cricket_desc = NULL;
+    const cricket::SessionDescription* cricket_desc = nullptr;
     if (current_desc) {
       cricket_desc = current_desc->description();
       session_id = current_desc->session_id();
     }
 
     desc_factory_->set_secure(secure_policy);
     JsepSessionDescription* offer(
         new JsepSessionDescription(JsepSessionDescription::kOffer));
     if (!offer->Initialize(desc_factory_->CreateOffer(options, cricket_desc),
                            session_id, session_version)) {
       delete offer;
-      offer = NULL;
+      offer = nullptr;
     }
     return offer;
   }
   JsepSessionDescription* CreateRemoteOffer(
       cricket::MediaSessionOptions options) {
     return CreateRemoteOfferWithVersion(options, cricket::SEC_ENABLED,
-                                        kSessionVersion, NULL);
+                                        kSessionVersion, nullptr);
   }
   JsepSessionDescription* CreateRemoteOffer(
       cricket::MediaSessionOptions options, cricket::SecurePolicy sdes_policy) {
-    return CreateRemoteOfferWithVersion(
-        options, sdes_policy, kSessionVersion, NULL);
+    return CreateRemoteOfferWithVersion(options, sdes_policy, kSessionVersion,
+                                        nullptr);
   }
   JsepSessionDescription* CreateRemoteOffer(
       cricket::MediaSessionOptions options,
       const SessionDescriptionInterface* current_desc) {
     return CreateRemoteOfferWithVersion(options, cricket::SEC_ENABLED,
                                         kSessionVersion, current_desc);
   }
 
   JsepSessionDescription* CreateRemoteOfferWithSctpPort(
       const char* sctp_stream_name, int new_port,
@@ skipping 13 matching lines @@
     char new_port_str[16];
     rtc::sprintfn(new_port_str, sizeof(new_port_str), "%d", new_port);
     std::string offer_str;
     offer_basis->ToString(&offer_str);
     rtc::replace_substrs(default_port_str, strlen(default_port_str),
                                new_port_str, strlen(new_port_str),
                                &offer_str);
     JsepSessionDescription* offer = new JsepSessionDescription(
         offer_basis->type());
     delete offer_basis;
-    offer->Initialize(offer_str, NULL);
+    offer->Initialize(offer_str, nullptr);
     return offer;
   }
 
   // Create a remote offer. Call SendAudioVideoStreamX()
   // before this function to decide which streams to create.
   JsepSessionDescription* CreateRemoteOffer() {
     cricket::MediaSessionOptions 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());
     JsepSessionDescription* answer(
         new JsepSessionDescription(JsepSessionDescription::kAnswer));
-    if (!answer->Initialize(desc_factory_->CreateAnswer(offer->description(),
-                                                        options, NULL),
-                            session_id, kSessionVersion)) {
+    if (!answer->Initialize(
+            desc_factory_->CreateAnswer(offer->description(), options, nullptr),
+            session_id, kSessionVersion)) {
       delete answer;
-      answer = NULL;
+      answer = nullptr;
     }
     return answer;
   }
 
   JsepSessionDescription* CreateRemoteAnswer(
       const SessionDescriptionInterface* offer,
       cricket::MediaSessionOptions options) {
       return CreateRemoteAnswer(offer, options, cricket::SEC_REQUIRED);
   }
 
@@ skipping 31 matching lines @@
       // for rtp and rtcp.
       expected_candidate_num = 4;
       // Disable rtcp-mux from the answer
       const std::string kRtcpMux = "a=rtcp-mux";
       const std::string kXRtcpMux = "a=xrtcp-mux";
       rtc::replace_substrs(kRtcpMux.c_str(), kRtcpMux.length(),
                                  kXRtcpMux.c_str(), kXRtcpMux.length(),
                                  &sdp);
     }
 
-    SessionDescriptionInterface* new_answer = CreateSessionDescription(
-        JsepSessionDescription::kAnswer, sdp, NULL);
+    SessionDescriptionInterface* new_answer =
+        CreateSessionDescription(JsepSessionDescription::kAnswer, sdp, nullptr);
 
     // SetRemoteDescription to enable rtcp mux.
     SetRemoteDescriptionWithoutError(new_answer);
     EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
     EXPECT_EQ(expected_candidate_num, observer_.mline_0_candidates_.size());
     if (bundle) {
       EXPECT_EQ(0, observer_.mline_1_candidates_.size());
     } else {
       EXPECT_EQ(expected_candidate_num, observer_.mline_1_candidates_.size());
     }
@@ skipping 135 matching lines @@
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringGathering,
                    observer_.ice_gathering_state_, kIceCandidatesTimeout);
     EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
                    observer_.ice_gathering_state_, kIceCandidatesTimeout);
 
     std::string sdp;
     offer->ToString(&sdp);
     SessionDescriptionInterface* desc = webrtc::CreateSessionDescription(
         JsepSessionDescription::kAnswer, sdp, nullptr);
-    ASSERT_TRUE(desc != NULL);
+    ASSERT_TRUE(desc != nullptr);
     SetRemoteDescriptionWithoutError(desc);
 
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
                    observer_.ice_connection_state_, kIceCandidatesTimeout);
 
     // The ice connection state is "Connected" too briefly to catch in a test.
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                    observer_.ice_connection_state_, kIceCandidatesTimeout);
   }
 
@@ skipping 69 matching lines @@
     std::vector<cricket::AudioCodec> codecs =
         media_engine_->audio_send_codecs();
     codecs.push_back(kCNCodec1);
     codecs.push_back(kCNCodec2);
     media_engine_->SetAudioCodecs(codecs);
     desc_factory_->set_audio_codecs(codecs, codecs);
   }
 
   bool VerifyNoCNCodecs(const cricket::ContentInfo* content) {
     const cricket::ContentDescription* description = content->description;
-    RTC_CHECK(description != NULL);
+    RTC_CHECK(description != nullptr);
     const cricket::AudioContentDescription* audio_content_desc =
         static_cast<const cricket::AudioContentDescription*>(description);
-    RTC_CHECK(audio_content_desc != NULL);
+    RTC_CHECK(audio_content_desc != nullptr);
     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;
     RTC_CHECK(session_.get());
@@ skipping 22 matching lines @@
   }
 
   void VerifyMultipleAsyncCreateDescriptionAfterInit(
       bool success, CreateSessionDescriptionRequest::Type type) {
     RTC_CHECK(session_);
     SetFactoryDtlsSrtp();
     if (type == CreateSessionDescriptionRequest::kAnswer) {
       cricket::MediaSessionOptions options;
       std::unique_ptr<JsepSessionDescription> offer(
           CreateRemoteOffer(options, cricket::SEC_DISABLED));
-      ASSERT_TRUE(offer.get() != NULL);
+      ASSERT_TRUE(offer.get() != nullptr);
       SetRemoteDescriptionWithoutError(offer.release());
     }
 
     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], 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) {
-        EXPECT_TRUE(observers[i]->description() != NULL);
+        EXPECT_TRUE(observers[i]->description() != nullptr);
       } else {
-        EXPECT_TRUE(observers[i]->description() == NULL);
+        EXPECT_TRUE(observers[i]->description() == nullptr);
       }
     }
   }
 
   void ConfigureAllocatorWithTurn() {
     cricket::RelayServerConfig turn_server(cricket::RELAY_TURN);
     cricket::RelayCredentials credentials(kTurnUsername, kTurnPassword);
     turn_server.credentials = credentials;
     turn_server.ports.push_back(
         cricket::ProtocolAddress(kTurnUdpIntAddr, cricket::PROTO_UDP));
@@ skipping 95 matching lines @@
   EXPECT_EQ(6u, observer_.mline_0_candidates_.size());
   EXPECT_EQ(6u, observer_.mline_1_candidates_.size());
   // Destroy session before scoped fake clock goes out of scope to avoid TSan
   // warning.
   session_->Close();
   session_.reset(nullptr);
 }
 
 TEST_F(WebRtcSessionTest, SetSdpFailedOnInvalidSdp) {
   Init();
-  SessionDescriptionInterface* offer = NULL;
-  // Since |offer| is NULL, there's no way to tell if it's an offer or answer.
+  SessionDescriptionInterface* offer = nullptr;
+  // Since |offer| is null, there's no way to tell if it's an offer or answer.
   std::string unknown_action;
   SetLocalDescriptionExpectError(unknown_action, kInvalidSdp, offer);
   SetRemoteDescriptionExpectError(unknown_action, kInvalidSdp, offer);
 }
 
 // Test creating offers and receive answers and make sure the
 // media engine creates the expected send and receive streams.
 TEST_F(WebRtcSessionTest, TestCreateSdesOfferReceiveSdesAnswer) {
   Init();
   SendAudioVideoStream1();
@@ skipping 104 matching lines @@
   // Make sure we have no send streams.
   EXPECT_EQ(0u, video_channel_->send_streams().size());
   EXPECT_EQ(0u, voice_channel_->send_streams().size());
 }
 
 TEST_F(WebRtcSessionTest, SetLocalSdpFailedOnCreateChannel) {
   Init();
   media_engine_->set_fail_create_channel(true);
 
   SessionDescriptionInterface* offer = CreateOffer();
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   // SetRemoteDescription and SetLocalDescription will take the ownership of
   // the offer.
   SetRemoteDescriptionOfferExpectError(kCreateChannelFailed, offer);
   offer = CreateOffer();
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   SetLocalDescriptionOfferExpectError(kCreateChannelFailed, offer);
 }
 
 //
 // Tests for creating/setting SDP under different SDES/DTLS polices:
 //
 // --DTLS off and SDES on
 // TestCreateSdesOfferReceiveSdesAnswer/TestReceiveSdesOfferCreateSdesAnswer:
 //     set local/remote offer/answer with crypto --> success
 // TestSetNonSdesOfferWhenSdesOn: set local/remote offer without crypto --->
@@ skipping 21 matching lines @@
 //
 
 // Test that we return a failure when applying a remote/local offer that doesn't
 // have cryptos enabled when DTLS is off.
 TEST_F(WebRtcSessionTest, TestSetNonSdesOfferWhenSdesOn) {
   Init();
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   JsepSessionDescription* offer = CreateRemoteOffer(
       options, cricket::SEC_DISABLED);
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   VerifyNoCryptoParams(offer->description(), false);
   // SetRemoteDescription and SetLocalDescription will take the ownership of
   // the offer.
   SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto, offer);
   offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   SetLocalDescriptionOfferExpectError(kSdpWithoutSdesCrypto, offer);
 }
 
 // Test that we return a failure when applying a local answer that doesn't have
 // cryptos enabled when DTLS is off.
 TEST_F(WebRtcSessionTest, TestSetLocalNonSdesAnswerWhenSdesOn) {
   Init();
-  SessionDescriptionInterface* offer = NULL;
-  SessionDescriptionInterface* answer = NULL;
+  SessionDescriptionInterface* offer = nullptr;
+  SessionDescriptionInterface* answer = nullptr;
   CreateCryptoOfferAndNonCryptoAnswer(&offer, &answer);
   // SetRemoteDescription and SetLocalDescription will take the ownership of
   // the offer.
   SetRemoteDescriptionWithoutError(offer);
   SetLocalDescriptionAnswerExpectError(kSdpWithoutSdesCrypto, answer);
 }
 
 // Test we will return fail when apply an remote answer that doesn't have
 // crypto enabled when DTLS is off.
 TEST_F(WebRtcSessionTest, TestSetRemoteNonSdesAnswerWhenSdesOn) {
   Init();
-  SessionDescriptionInterface* offer = NULL;
-  SessionDescriptionInterface* answer = NULL;
+  SessionDescriptionInterface* offer = nullptr;
+  SessionDescriptionInterface* answer = nullptr;
   CreateCryptoOfferAndNonCryptoAnswer(&offer, &answer);
   // SetRemoteDescription and SetLocalDescription will take the ownership of
   // the offer.
   SetLocalDescriptionWithoutError(offer);
   SetRemoteDescriptionAnswerExpectError(kSdpWithoutSdesCrypto, answer);
 }
 
 // Test that we accept an offer with a DTLS fingerprint when DTLS is on
 // and that we return an answer with a DTLS fingerprint.
 TEST_P(WebRtcSessionTest, TestReceiveDtlsOfferCreateDtlsAnswer) {
   SendAudioVideoStream1();
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   JsepSessionDescription* offer =
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   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();
-  ASSERT_TRUE(answer != NULL);
+  ASSERT_TRUE(answer != nullptr);
   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
 // and then we accept a remote answer with a DTLS fingerprint successfully.
 TEST_P(WebRtcSessionTest, TestCreateDtlsOfferReceiveDtlsAnswer) {
   SendAudioVideoStream1();
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
   // Verify that we get a crypto fingerprint in the answer.
   SessionDescriptionInterface* offer = CreateOffer();
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   VerifyFingerprintStatus(offer->description(), true);
   // Check that we don't have an a=crypto line in the offer.
   VerifyNoCryptoParams(offer->description(), true);
 
   // Now set the local description, which should work, even without a=crypto.
   SetLocalDescriptionWithoutError(offer);
 
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   JsepSessionDescription* answer =
       CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
-  ASSERT_TRUE(answer != NULL);
+  ASSERT_TRUE(answer != nullptr);
   VerifyFingerprintStatus(answer->description(), true);
   VerifyNoCryptoParams(answer->description(), true);
 
   // SetRemoteDescription will take the ownership of the answer.
   SetRemoteDescriptionWithoutError(answer);
 }
 
 // Test that if we support DTLS and the other side didn't offer a fingerprint,
 // we will fail to set the remote description.
 TEST_P(WebRtcSessionTest, TestReceiveNonDtlsOfferWhenDtlsOn) {
   InitWithDtls(GetParam());
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   options.bundle_enabled = true;
   JsepSessionDescription* offer = CreateRemoteOffer(
       options, cricket::SEC_REQUIRED);
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   VerifyFingerprintStatus(offer->description(), false);
   VerifyCryptoParams(offer->description());
 
   // SetRemoteDescription will take the ownership of the offer.
   SetRemoteDescriptionOfferExpectError(
       kSdpWithoutDtlsFingerprint, offer);
 
   offer = CreateRemoteOffer(options, cricket::SEC_REQUIRED);
   // SetLocalDescription will take the ownership of the offer.
   SetLocalDescriptionOfferExpectError(
       kSdpWithoutDtlsFingerprint, offer);
 }
 
 // Test that we return a failure when applying a local answer that doesn't have
 // a DTLS fingerprint when DTLS is required.
 TEST_P(WebRtcSessionTest, TestSetLocalNonDtlsAnswerWhenDtlsOn) {
   InitWithDtls(GetParam());
-  SessionDescriptionInterface* offer = NULL;
-  SessionDescriptionInterface* answer = NULL;
+  SessionDescriptionInterface* offer = nullptr;
+  SessionDescriptionInterface* answer = nullptr;
   CreateDtlsOfferAndNonDtlsAnswer(&offer, &answer);
 
   // SetRemoteDescription and SetLocalDescription will take the ownership of
   // the offer and answer.
   SetRemoteDescriptionWithoutError(offer);
   SetLocalDescriptionAnswerExpectError(
       kSdpWithoutDtlsFingerprint, answer);
 }
 
 // Test that we return a failure when applying a remote answer that doesn't have
@@ skipping 17 matching lines @@
 
 // Test that we create a local offer without SDES or DTLS and accept a remote
 // answer without SDES or DTLS when encryption is disabled.
 TEST_P(WebRtcSessionTest, TestCreateOfferReceiveAnswerWithoutEncryption) {
   SendAudioVideoStream1();
   options_.disable_encryption = true;
   InitWithDtls(GetParam());
 
   // Verify that we get a crypto fingerprint in the answer.
   SessionDescriptionInterface* offer = CreateOffer();
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   VerifyFingerprintStatus(offer->description(), false);
   // Check that we don't have an a=crypto line in the offer.
   VerifyNoCryptoParams(offer->description(), false);
 
   // Now set the local description, which should work, even without a=crypto.
   SetLocalDescriptionWithoutError(offer);
 
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   JsepSessionDescription* answer =
       CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
-  ASSERT_TRUE(answer != NULL);
+  ASSERT_TRUE(answer != nullptr);
   VerifyFingerprintStatus(answer->description(), false);
   VerifyNoCryptoParams(answer->description(), false);
 
   // SetRemoteDescription will take the ownership of the answer.
   SetRemoteDescriptionWithoutError(answer);
 }
 
 // Test that we create a local answer without SDES or DTLS and accept a remote
 // offer without SDES or DTLS when encryption is disabled.
 TEST_P(WebRtcSessionTest, TestCreateAnswerReceiveOfferWithoutEncryption) {
   options_.disable_encryption = true;
   InitWithDtls(GetParam());
 
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   JsepSessionDescription* offer =
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   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();
-  ASSERT_TRUE(answer != NULL);
+  ASSERT_TRUE(answer != nullptr);
   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
 // SSL roles have been negotiated for different transports.
@@ skipping 196 matching lines @@
 
   EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate1));
   candidate.set_component(2);
   candidate.set_address(rtc::SocketAddress("2.2.2.2", 6000));
   JsepIceCandidate ice_candidate2(kMediaContentName0, 0, candidate);
   EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate2));
 
   // Verifying the candidates are copied properly from internal vector.
   const SessionDescriptionInterface* remote_desc =
       session_->remote_description();
-  ASSERT_TRUE(remote_desc != NULL);
+  ASSERT_TRUE(remote_desc != nullptr);
   ASSERT_EQ(2u, remote_desc->number_of_mediasections());
   const IceCandidateCollection* candidates =
       remote_desc->candidates(kMediaContentIndex0);
   ASSERT_EQ(2u, candidates->count());
   EXPECT_EQ(kMediaContentIndex0, candidates->at(0)->sdp_mline_index());
   EXPECT_EQ(kMediaContentName0, candidates->at(0)->sdp_mid());
   EXPECT_EQ(1, candidates->at(0)->candidate().component());
   EXPECT_EQ(2, candidates->at(1)->candidate().component());
 
   // |ice_candidate3| is identical to |ice_candidate2|.  It can be added
@@ skipping 21 matching lines @@
   cricket::Candidate candidate1;
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate1(kMediaContentName0, kMediaContentIndex0,
                                   candidate1);
   SendAudioVideoStream1();
   CreateAndSetRemoteOfferAndLocalAnswer();
 
   EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate1));
   const SessionDescriptionInterface* remote_desc =
       session_->remote_description();
-  ASSERT_TRUE(remote_desc != NULL);
+  ASSERT_TRUE(remote_desc != nullptr);
   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());
 
   // Update the RemoteSessionDescription with a new session description and
   // a candidate and check that the new remote session description contains both
   // candidates.
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   cricket::Candidate candidate2;
   JsepIceCandidate ice_candidate2(kMediaContentName0, kMediaContentIndex0,
                                   candidate2);
   EXPECT_TRUE(offer->AddCandidate(&ice_candidate2));
   SetRemoteDescriptionWithoutError(offer);
 
   remote_desc = session_->remote_description();
-  ASSERT_TRUE(remote_desc != NULL);
+  ASSERT_TRUE(remote_desc != nullptr);
   ASSERT_EQ(2u, remote_desc->number_of_mediasections());
   candidates = remote_desc->candidates(kMediaContentIndex0);
   ASSERT_EQ(2u, candidates->count());
   EXPECT_EQ(kMediaContentIndex0, candidates->at(0)->sdp_mline_index());
   // Username and password have be updated with the TransportInfo of the
   // SessionDescription, won't be equal to the original one.
   candidate2.set_username(candidates->at(0)->candidate().username());
   candidate2.set_password(candidates->at(0)->candidate().password());
   EXPECT_TRUE(candidate2.IsEquivalent(candidates->at(0)->candidate()));
   EXPECT_EQ(kMediaContentIndex0, candidates->at(1)->sdp_mline_index());
@@ skipping 17 matching lines @@
   // Enable Continual Gathering.
   cricket::IceConfig config;
   config.continual_gathering_policy = cricket::GATHER_CONTINUALLY;
   session_->SetIceConfig(config);
   SendAudioVideoStream1();
   CreateAndSetRemoteOfferAndLocalAnswer();
 
   const SessionDescriptionInterface* local_desc = session_->local_description();
   const IceCandidateCollection* candidates =
       local_desc->candidates(kMediaContentIndex0);
-  ASSERT_TRUE(candidates != NULL);
+  ASSERT_TRUE(candidates != nullptr);
   EXPECT_EQ(0u, candidates->count());
 
   // Since we're using continual gathering, we won't get "gathering done".
   EXPECT_EQ_WAIT(2u, candidates->count(), kIceCandidatesTimeout);
 
   local_desc = session_->local_description();
   candidates = local_desc->candidates(kMediaContentIndex0);
-  ASSERT_TRUE(candidates != NULL);
+  ASSERT_TRUE(candidates != nullptr);
   EXPECT_LT(0u, candidates->count());
   candidates = local_desc->candidates(1);
-  ASSERT_TRUE(candidates != NULL);
+  ASSERT_TRUE(candidates != nullptr);
   EXPECT_EQ(0u, candidates->count());
 
   // Update the session descriptions.
   SendAudioVideoStream1();
   CreateAndSetRemoteOfferAndLocalAnswer();
 
   local_desc = session_->local_description();
   candidates = local_desc->candidates(kMediaContentIndex0);
-  ASSERT_TRUE(candidates != NULL);
+  ASSERT_TRUE(candidates != nullptr);
   EXPECT_LT(0u, candidates->count());
   candidates = local_desc->candidates(1);
-  ASSERT_TRUE(candidates != NULL);
+  ASSERT_TRUE(candidates != nullptr);
   EXPECT_EQ(0u, candidates->count());
 
   candidates = local_desc->candidates(kMediaContentIndex0);
   size_t num_local_candidates = candidates->count();
   // Bring down the network interface to trigger candidate removals.
   RemoveInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
   // Verify that all local candidates are removed.
   EXPECT_EQ(0, observer_.num_candidates_removed_);
   EXPECT_EQ_WAIT(num_local_candidates, observer_.num_candidates_removed_,
                  kIceCandidatesTimeout);
   EXPECT_EQ_WAIT(0u, candidates->count(), kIceCandidatesTimeout);
 }
 
 // Tests that if continual gathering is disabled, local candidates won't be
 // removed when the interface is turned down.
 TEST_F(WebRtcSessionTest, TestLocalCandidatesNotRemovedIfNotGatherContinually) {
   AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
   Init();
   SendAudioVideoStream1();
   CreateAndSetRemoteOfferAndLocalAnswer();
 
   const SessionDescriptionInterface* local_desc = session_->local_description();
   const IceCandidateCollection* candidates =
       local_desc->candidates(kMediaContentIndex0);
-  ASSERT_TRUE(candidates != NULL);
+  ASSERT_TRUE(candidates != nullptr);
   EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
 
   size_t num_local_candidates = candidates->count();
   EXPECT_LT(0u, num_local_candidates);
   // By default, Continual Gathering is disabled.
   // Bring down the network interface.
   RemoveInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
   // Verify that the local candidates are not removed.
   rtc::Thread::Current()->ProcessMessages(1000);
   EXPECT_EQ(0, observer_.num_candidates_removed_);
   EXPECT_EQ(num_local_candidates, candidates->count());
 }
 
 // Test that we can set a remote session description with remote candidates.
 TEST_F(WebRtcSessionTest, TestSetRemoteSessionDescriptionWithCandidates) {
   Init();
 
   cricket::Candidate candidate1;
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate(kMediaContentName0, kMediaContentIndex0,
                                  candidate1);
   SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
 
   EXPECT_TRUE(offer->AddCandidate(&ice_candidate));
   SetRemoteDescriptionWithoutError(offer);
 
   const SessionDescriptionInterface* remote_desc =
       session_->remote_description();
-  ASSERT_TRUE(remote_desc != NULL);
+  ASSERT_TRUE(remote_desc != nullptr);
   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();
   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);
 
   std::unique_ptr<SessionDescriptionInterface> local_offer(CreateOffer());
 
-  ASSERT_TRUE(local_offer->candidates(kMediaContentIndex0) != NULL);
+  ASSERT_TRUE(local_offer->candidates(kMediaContentIndex0) != nullptr);
   EXPECT_LT(0u, local_offer->candidates(kMediaContentIndex0)->count());
 
   SessionDescriptionInterface* remote_offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(remote_offer);
   SessionDescriptionInterface* answer = CreateAnswer();
-  ASSERT_TRUE(answer->candidates(kMediaContentIndex0) != NULL);
+  ASSERT_TRUE(answer->candidates(kMediaContentIndex0) != nullptr);
   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();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
@@ skipping 15 matching lines @@
                              kAudioMidReplaceStr.c_str(),
                              kAudioMidReplaceStr.length(),
                              &sdp);
   // Replacing |video| with |video_content_name|.
   rtc::replace_substrs(kVideoMid.c_str(), kVideoMid.length(),
                              kVideoMidReplaceStr.c_str(),
                              kVideoMidReplaceStr.length(),
                              &sdp);
 
   SessionDescriptionInterface* modified_offer =
-      CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
+      CreateSessionDescription(JsepSessionDescription::kOffer, sdp, nullptr);
 
   SetRemoteDescriptionWithoutError(modified_offer);
 
   SessionDescriptionInterface* answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 
   rtc::PacketTransportInternal* voice_transport_channel =
       session_->voice_rtp_transport_channel();
-  EXPECT_TRUE(voice_transport_channel != NULL);
+  EXPECT_TRUE(voice_transport_channel != nullptr);
   EXPECT_EQ(voice_transport_channel->debug_name(),
             "audio_content_name " +
                 std::to_string(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   rtc::PacketTransportInternal* video_transport_channel =
       session_->video_rtp_transport_channel();
-  ASSERT_TRUE(video_transport_channel != NULL);
+  ASSERT_TRUE(video_transport_channel != nullptr);
   EXPECT_EQ(video_transport_channel->debug_name(),
             "video_content_name " +
                 std::to_string(cricket::ICE_CANDIDATE_COMPONENT_RTP));
-  EXPECT_TRUE((video_channel_ = media_engine_->GetVideoChannel(0)) != NULL);
-  EXPECT_TRUE((voice_channel_ = media_engine_->GetVoiceChannel(0)) != NULL);
+  EXPECT_TRUE((video_channel_ = media_engine_->GetVideoChannel(0)) != nullptr);
+  EXPECT_TRUE((voice_channel_ = media_engine_->GetVoiceChannel(0)) != nullptr);
 }
 
 // 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();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  EXPECT_TRUE(content != nullptr);
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  EXPECT_TRUE(content == nullptr);
 }
 
 // Test that an offer contains the correct media content descriptions based on
 // the send streams when no constraints have been set.
 TEST_F(WebRtcSessionTest, CreateOfferWithoutConstraints) {
   Init();
   // Test Audio only offer.
   SendAudioOnlyStream2();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  EXPECT_TRUE(content != nullptr);
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  EXPECT_TRUE(content == nullptr);
 
   // Test Audio / Video offer.
   SendAudioVideoStream1();
   offer.reset(CreateOffer());
   content = cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  EXPECT_TRUE(content != nullptr);
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  EXPECT_TRUE(content != nullptr);
 }
 
 // Test that an offer contains no media content descriptions if
 // kOfferToReceiveVideo and kOfferToReceiveAudio constraints are set to false.
 TEST_F(WebRtcSessionTest, CreateOfferWithConstraintsWithoutStreams) {
   Init();
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.offer_to_receive_audio = 0;
   options.offer_to_receive_video = 0;
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
 
-  ASSERT_TRUE(offer != NULL);
+  ASSERT_TRUE(offer != nullptr);
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  EXPECT_TRUE(content == nullptr);
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  EXPECT_TRUE(content == nullptr);
 }
 
 // Test that an offer contains only audio media content descriptions if
 // kOfferToReceiveAudio constraints are set to true.
 TEST_F(WebRtcSessionTest, CreateAudioOnlyOfferWithConstraints) {
   Init();
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.offer_to_receive_audio =
       RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  EXPECT_TRUE(content != nullptr);
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  EXPECT_TRUE(content == nullptr);
 }
 
 // Test that an offer contains audio and video media content descriptions if
 // kOfferToReceiveAudio and kOfferToReceiveVideo constraints are set to true.
 TEST_F(WebRtcSessionTest, CreateOfferWithConstraints) {
   Init();
   // Test Audio / Video offer.
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.offer_to_receive_audio =
       RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
   options.offer_to_receive_video =
       RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  EXPECT_TRUE(content != nullptr);
 
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  EXPECT_TRUE(content != nullptr);
 
   // Sets constraints to false and verifies that audio/video contents are
   // removed.
   options.offer_to_receive_audio = 0;
   options.offer_to_receive_video = 0;
   offer.reset(CreateOffer(options));
 
   content = cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  EXPECT_TRUE(content == nullptr);
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  EXPECT_TRUE(content == nullptr);
 }
 
 // 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);
+  EXPECT_TRUE(CreateAnswer() == nullptr);
 }
 
 // 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.
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_FALSE(content->rejected);
 
   content = cricket::GetFirstVideoContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   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;
 
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
-  ASSERT_TRUE(cricket::GetFirstVideoContent(offer->description()) == NULL);
-  ASSERT_TRUE(cricket::GetFirstAudioContent(offer->description()) != NULL);
+  ASSERT_TRUE(cricket::GetFirstVideoContent(offer->description()) == nullptr);
+  ASSERT_TRUE(cricket::GetFirstAudioContent(offer->description()) != nullptr);
 
   SetRemoteDescriptionWithoutError(offer.release());
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_FALSE(content->rejected);
 
-  EXPECT_TRUE(cricket::GetFirstVideoContent(answer->description()) == NULL);
+  EXPECT_TRUE(cricket::GetFirstVideoContent(answer->description()) == nullptr);
 }
 
 // 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.
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
   // Test with a stream with tracks.
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_FALSE(content->rejected);
 
   content = cricket::GetFirstVideoContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   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.
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
   cricket::MediaSessionOptions session_options;
   session_options.recv_audio = false;
   session_options.recv_video = false;
   std::unique_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(session_options));
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_TRUE(content->rejected);
 
   content = cricket::GetFirstVideoContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   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.
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
   cricket::MediaSessionOptions options;
   options.recv_audio = false;
   options.recv_video = false;
 
   // Test with a stream with tracks.
   SendAudioVideoStream1();
   std::unique_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);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_FALSE(content->rejected);
 
   // TODO(perkj): Should the direction be set to SEND_ONLY?
   content = cricket::GetFirstVideoContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_FALSE(content->rejected);
 }
 
 TEST_F(WebRtcSessionTest, CreateOfferWithoutCNCodecs) {
   AddCNCodecs();
   Init();
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.offer_to_receive_audio =
       RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
   options.voice_activity_detection = false;
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  EXPECT_TRUE(content != nullptr);
   EXPECT_TRUE(VerifyNoCNCodecs(content));
 }
 
 TEST_F(WebRtcSessionTest, CreateAnswerWithoutCNCodecs) {
   AddCNCodecs();
   Init();
   // Create a remote offer with audio and video content.
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
   cricket::MediaSessionOptions options;
   options.vad_enabled = false;
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer(options));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   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();
-  EXPECT_TRUE(media_engine_->GetVideoChannel(0) == NULL);
-  EXPECT_TRUE(media_engine_->GetVoiceChannel(0) == NULL);
+  EXPECT_TRUE(media_engine_->GetVideoChannel(0) == nullptr);
+  EXPECT_TRUE(media_engine_->GetVoiceChannel(0) == nullptr);
 
   SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
 
   cricket::MediaSessionOptions options;
   SessionDescriptionInterface* answer = CreateRemoteAnswer(offer, options);
 
   // SetLocalDescription and SetRemoteDescriptions takes ownership of offer
   // and answer;
   SetLocalDescriptionWithoutError(offer);
   SetRemoteDescriptionWithoutError(answer);
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
-  ASSERT_TRUE(video_channel_ == NULL);
+  ASSERT_TRUE(video_channel_ == nullptr);
 
   ASSERT_EQ(0u, voice_channel_->recv_streams().size());
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_EQ(kAudioTrack1, voice_channel_->send_streams()[0].id);
 
   // Let the remote end update the session descriptions, with Audio and Video.
   SendAudioVideoStream2();
   CreateAndSetRemoteOfferAndLocalAnswer();
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
-  ASSERT_TRUE(video_channel_ != NULL);
-  ASSERT_TRUE(voice_channel_ != NULL);
+  ASSERT_TRUE(video_channel_ != nullptr);
+  ASSERT_TRUE(voice_channel_ != nullptr);
 
   ASSERT_EQ(1u, video_channel_->recv_streams().size());
   ASSERT_EQ(1u, video_channel_->send_streams().size());
   EXPECT_EQ(kVideoTrack2, video_channel_->recv_streams()[0].id);
   EXPECT_EQ(kVideoTrack2, video_channel_->send_streams()[0].id);
   ASSERT_EQ(1u, voice_channel_->recv_streams().size());
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
   EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
 
   // Change session back to audio only.
   SendAudioOnlyStream2();
   CreateAndSetRemoteOfferAndLocalAnswer();
 
   EXPECT_EQ(0u, video_channel_->recv_streams().size());
   ASSERT_EQ(1u, voice_channel_->recv_streams().size());
   EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
 }
 
 // This test verifies the call setup when remote answer with video only and
 // later updates with audio.
 TEST_F(WebRtcSessionTest, TestAVOfferWithVideoOnlyAnswer) {
   Init();
-  EXPECT_TRUE(media_engine_->GetVideoChannel(0) == NULL);
-  EXPECT_TRUE(media_engine_->GetVoiceChannel(0) == NULL);
+  EXPECT_TRUE(media_engine_->GetVideoChannel(0) == nullptr);
+  EXPECT_TRUE(media_engine_->GetVoiceChannel(0) == nullptr);
   SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
 
   cricket::MediaSessionOptions options;
   options.recv_audio = false;
   options.recv_video = true;
   SessionDescriptionInterface* answer = CreateRemoteAnswer(
       offer, options, cricket::SEC_ENABLED);
 
   // SetLocalDescription and SetRemoteDescriptions takes ownership of offer
   // and answer.
   SetLocalDescriptionWithoutError(offer);
   SetRemoteDescriptionWithoutError(answer);
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
-  ASSERT_TRUE(voice_channel_ == NULL);
-  ASSERT_TRUE(video_channel_ != NULL);
+  ASSERT_TRUE(voice_channel_ == nullptr);
+  ASSERT_TRUE(video_channel_ != nullptr);
 
   EXPECT_EQ(0u, video_channel_->recv_streams().size());
   ASSERT_EQ(1u, video_channel_->send_streams().size());
   EXPECT_EQ(kVideoTrack1, video_channel_->send_streams()[0].id);
 
   // Update the session descriptions, with Audio and Video.
   SendAudioVideoStream2();
   CreateAndSetRemoteOfferAndLocalAnswer();
 
   voice_channel_ = media_engine_->GetVoiceChannel(0);
-  ASSERT_TRUE(voice_channel_ != NULL);
+  ASSERT_TRUE(voice_channel_ != nullptr);
 
   ASSERT_EQ(1u, voice_channel_->recv_streams().size());
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
   EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
 
   // Change session back to video only.
   SendVideoOnlyStream2();
   CreateAndSetRemoteOfferAndLocalAnswer();
 
@@ skipping 47 matching lines @@
 // This test verifies that setLocalDescription fails if
 // no a=ice-ufrag and a=ice-pwd lines are present in the SDP.
 TEST_F(WebRtcSessionTest, TestSetLocalDescriptionWithoutIce) {
   Init();
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   std::string sdp;
   RemoveIceUfragPwdLines(offer.get(), &sdp);
   SessionDescriptionInterface* modified_offer =
-    CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
+      CreateSessionDescription(JsepSessionDescription::kOffer, sdp, nullptr);
   SetLocalDescriptionOfferExpectError(kSdpWithoutIceUfragPwd, modified_offer);
 }
 
 // This test verifies that setRemoteDescription fails if
 // no a=ice-ufrag and a=ice-pwd lines are present in the SDP.
 TEST_F(WebRtcSessionTest, TestSetRemoteDescriptionWithoutIce) {
   Init();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
   std::string sdp;
   RemoveIceUfragPwdLines(offer.get(), &sdp);
   SessionDescriptionInterface* modified_offer =
-    CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
+      CreateSessionDescription(JsepSessionDescription::kOffer, sdp, nullptr);
   SetRemoteDescriptionOfferExpectError(kSdpWithoutIceUfragPwd, modified_offer);
 }
 
 // This test verifies that setLocalDescription fails if local offer has
 // too short ice ufrag and pwd strings.
 TEST_F(WebRtcSessionTest, TestSetLocalDescriptionInvalidIceCredentials) {
   Init();
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
   // Modifying ice ufrag and pwd in local offer with strings smaller than the
@@ skipping 130 matching lines @@
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   SetRemoteDescriptionWithoutError(offer);
 
   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_TRUE(voice_channel != NULL);
+  ASSERT_TRUE(voice_channel != nullptr);
 
   // Checks if one of the transport channels contains a connection using a given
   // port.
   auto connection_with_remote_port = [this, voice_channel](int port) {
     std::unique_ptr<webrtc::SessionStats> stats = session_->GetStats_s();
     for (auto& kv : stats->transport_stats) {
       for (auto& chan_stat : kv.second.channel_stats) {
         for (auto& conn_info : chan_stat.connection_infos) {
           if (conn_info.remote_candidate.address().port() == port) {
             return true;
@@ skipping 313 matching lines @@
   // Negotiate an audio channel with MAX_BUNDLE enabled.
   SendAudioOnlyStream2();
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
                  observer_.ice_gathering_state_, kIceCandidatesTimeout);
   std::string sdp;
   offer->ToString(&sdp);
   SessionDescriptionInterface* answer = webrtc::CreateSessionDescription(
       JsepSessionDescription::kAnswer, sdp, nullptr);
-  ASSERT_TRUE(answer != NULL);
+  ASSERT_TRUE(answer != nullptr);
   SetRemoteDescriptionWithoutError(answer);
 
   // Wait for the ICE state to stabilize.
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  observer_.ice_connection_state_, kIceCandidatesTimeout);
   observer_.ice_connection_state_history_.clear();
 
   // Now add a video channel which should be using the same bundle transport.
   SendAudioVideoStream2();
   offer = CreateOffer();
   offer->ToString(&sdp);
   SetLocalDescriptionWithoutError(offer);
   answer = webrtc::CreateSessionDescription(JsepSessionDescription::kAnswer,
                                             sdp, nullptr);
-  ASSERT_TRUE(answer != NULL);
+  ASSERT_TRUE(answer != nullptr);
   SetRemoteDescriptionWithoutError(answer);
 
   // Wait for ICE state to stabilize
   rtc::Thread::Current()->ProcessMessages(0);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  observer_.ice_connection_state_, kIceCandidatesTimeout);
 
   // No ICE state changes are expected to happen.
   EXPECT_EQ(0, observer_.ice_connection_state_history_.size());
 }
 
 TEST_F(WebRtcSessionTest, TestRequireRtcpMux) {
   InitWithRtcpMuxPolicy(PeerConnectionInterface::kRtcpMuxPolicyRequire);
   SendAudioVideoStream1();
 
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   SessionDescriptionInterface* offer = CreateOffer(options);
   SetLocalDescriptionWithoutError(offer);
 
-  EXPECT_TRUE(session_->voice_rtcp_transport_channel() == NULL);
-  EXPECT_TRUE(session_->video_rtcp_transport_channel() == NULL);
+  EXPECT_TRUE(session_->voice_rtcp_transport_channel() == nullptr);
+  EXPECT_TRUE(session_->video_rtcp_transport_channel() == nullptr);
 
   SendAudioVideoStream2();
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(session_->local_description());
   SetRemoteDescriptionWithoutError(answer);
 
-  EXPECT_TRUE(session_->voice_rtcp_transport_channel() == NULL);
-  EXPECT_TRUE(session_->video_rtcp_transport_channel() == NULL);
+  EXPECT_TRUE(session_->voice_rtcp_transport_channel() == nullptr);
+  EXPECT_TRUE(session_->video_rtcp_transport_channel() == nullptr);
 }
 
 TEST_F(WebRtcSessionTest, TestNegotiateRtcpMux) {
   InitWithRtcpMuxPolicy(PeerConnectionInterface::kRtcpMuxPolicyNegotiate);
   SendAudioVideoStream1();
 
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   SessionDescriptionInterface* offer = CreateOffer(options);
   SetLocalDescriptionWithoutError(offer);
 
-  EXPECT_TRUE(session_->voice_rtcp_transport_channel() != NULL);
-  EXPECT_TRUE(session_->video_rtcp_transport_channel() != NULL);
+  EXPECT_TRUE(session_->voice_rtcp_transport_channel() != nullptr);
+  EXPECT_TRUE(session_->video_rtcp_transport_channel() != nullptr);
 
   SendAudioVideoStream2();
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(session_->local_description());
   SetRemoteDescriptionWithoutError(answer);
 
-  EXPECT_TRUE(session_->voice_rtcp_transport_channel() == NULL);
-  EXPECT_TRUE(session_->video_rtcp_transport_channel() == NULL);
+  EXPECT_TRUE(session_->voice_rtcp_transport_channel() == nullptr);
+  EXPECT_TRUE(session_->video_rtcp_transport_channel() == nullptr);
 }
 
 // This test verifies that SetLocalDescription and SetRemoteDescription fails
 // if BUNDLE is enabled but rtcp-mux is disabled in m-lines.
 TEST_F(WebRtcSessionTest, TestDisabledRtcpMuxWithBundleEnabled) {
   Init();
   SendAudioVideoStream1();
 
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.use_rtp_mux = true;
 
   SessionDescriptionInterface* offer = CreateOffer(options);
   std::string offer_str;
   offer->ToString(&offer_str);
   // Disable rtcp-mux
   const std::string rtcp_mux = "rtcp-mux";
   const std::string xrtcp_mux = "xrtcp-mux";
   rtc::replace_substrs(rtcp_mux.c_str(), rtcp_mux.length(),
                              xrtcp_mux.c_str(), xrtcp_mux.length(),
                              &offer_str);
   JsepSessionDescription* local_offer =
       new JsepSessionDescription(JsepSessionDescription::kOffer);
-  EXPECT_TRUE((local_offer)->Initialize(offer_str, NULL));
+  EXPECT_TRUE((local_offer)->Initialize(offer_str, nullptr));
   SetLocalDescriptionOfferExpectError(kBundleWithoutRtcpMux, local_offer);
   JsepSessionDescription* remote_offer =
       new JsepSessionDescription(JsepSessionDescription::kOffer);
-  EXPECT_TRUE((remote_offer)->Initialize(offer_str, NULL));
+  EXPECT_TRUE((remote_offer)->Initialize(offer_str, nullptr));
   SetRemoteDescriptionOfferExpectError(kBundleWithoutRtcpMux, remote_offer);
   // Trying unmodified SDP.
   SetLocalDescriptionWithoutError(offer);
 }
 
 TEST_F(WebRtcSessionTest, SetSetupGcm) {
   InitWithGcm();
   SendAudioVideoStream1();
   CreateAndSetRemoteOfferAndLocalAnswer();
 }
@@ skipping 46 matching lines @@
   // Different content names.
   std::string sdp;
   EXPECT_TRUE(answer->ToString(&sdp));
   const std::string kAudioMid = "a=mid:audio";
   const std::string kAudioMidReplaceStr = "a=mid:audio_content_name";
   rtc::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
                              kAudioMidReplaceStr.c_str(),
                              kAudioMidReplaceStr.length(),
                              &sdp);
   SessionDescriptionInterface* modified_answer1 =
-      CreateSessionDescription(JsepSessionDescription::kAnswer, sdp, NULL);
+      CreateSessionDescription(JsepSessionDescription::kAnswer, sdp, nullptr);
   SetRemoteDescriptionAnswerExpectError(kMlineMismatch, modified_answer1);
 
   // Different media types.
   EXPECT_TRUE(answer->ToString(&sdp));
   const std::string kAudioMline = "m=audio";
   const std::string kAudioMlineReplaceStr = "m=video";
   rtc::replace_substrs(kAudioMline.c_str(), kAudioMline.length(),
                              kAudioMlineReplaceStr.c_str(),
                              kAudioMlineReplaceStr.length(),
                              &sdp);
   SessionDescriptionInterface* modified_answer2 =
-      CreateSessionDescription(JsepSessionDescription::kAnswer, sdp, NULL);
+      CreateSessionDescription(JsepSessionDescription::kAnswer, sdp, nullptr);
   SetRemoteDescriptionAnswerExpectError(kMlineMismatch, modified_answer2);
 
   SetRemoteDescriptionWithoutError(answer.release());
 }
 
 // Verifying remote offer and local answer have matching m-lines as per
 // RFC 3264.
 TEST_F(WebRtcSessionTest, TestIncorrectMLinesInLocalAnswer) {
   Init();
   SendAudioVideoStream1();
@@ skipping 23 matching lines @@
   candidate.set_component(1);
   JsepIceCandidate ice_candidate(kMediaContentName0, kMediaContentIndex0,
                                  candidate);
   EXPECT_TRUE(offer->AddCandidate(&ice_candidate));
   cricket::Candidate candidate1;
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate1(kMediaContentName1, kMediaContentIndex1,
                                   candidate1);
   EXPECT_TRUE(offer->AddCandidate(&ice_candidate1));
   SetRemoteDescriptionWithoutError(offer);
-  ASSERT_TRUE(session_->voice_rtp_transport_channel() != NULL);
-  ASSERT_TRUE(session_->video_rtp_transport_channel() != NULL);
+  ASSERT_TRUE(session_->voice_rtp_transport_channel() != nullptr);
+  ASSERT_TRUE(session_->video_rtp_transport_channel() != nullptr);
 
   // 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();
   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();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   // Making sure SetLocalDescription correctly sets crypto value in
   // SessionDescription object after de-serialization of sdp string. The value
   // will be set as per MediaSessionDescriptionFactory.
   std::string offer_str;
   offer->ToString(&offer_str);
-  SessionDescriptionInterface* jsep_offer_str =
-      CreateSessionDescription(JsepSessionDescription::kOffer, offer_str, NULL);
+  SessionDescriptionInterface* jsep_offer_str = CreateSessionDescription(
+      JsepSessionDescription::kOffer, offer_str, nullptr);
   SetLocalDescriptionWithoutError(jsep_offer_str);
   EXPECT_TRUE(session_->voice_channel()->srtp_required_for_testing());
   EXPECT_TRUE(session_->video_channel()->srtp_required_for_testing());
 }
 
 // This test verifies the crypto parameter when security is disabled.
 TEST_F(WebRtcSessionTest, TestCryptoAfterSetLocalDescriptionWithDisabled) {
   options_.disable_encryption = true;
   Init();
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   // Making sure SetLocalDescription correctly sets crypto value in
   // SessionDescription object after de-serialization of sdp string. The value
   // will be set as per MediaSessionDescriptionFactory.
   std::string offer_str;
   offer->ToString(&offer_str);
-  SessionDescriptionInterface* jsep_offer_str =
-      CreateSessionDescription(JsepSessionDescription::kOffer, offer_str, NULL);
+  SessionDescriptionInterface* jsep_offer_str = CreateSessionDescription(
+      JsepSessionDescription::kOffer, offer_str, nullptr);
   SetLocalDescriptionWithoutError(jsep_offer_str);
   EXPECT_FALSE(session_->voice_channel()->srtp_required_for_testing());
   EXPECT_FALSE(session_->video_channel()->srtp_required_for_testing());
 }
 
 // This test verifies that an answer contains new ufrag and password if an offer
 // with new ufrag and password is received.
 TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewUfragAndPassword) {
   Init();
   cricket::MediaSessionOptions options;
@@ skipping 246 matching lines @@
   ASSERT_TRUE(session_->sctp_content_name());
   ASSERT_TRUE(session_->sctp_transport_name());
   EXPECT_EQ("data", *session_->sctp_content_name());
   EXPECT_EQ("audio", *session_->sctp_transport_name());
 }
 
 TEST_P(WebRtcSessionTest, TestCreateOfferWithSctpEnabledWithoutStreams) {
   InitWithDtls(GetParam());
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
-  EXPECT_TRUE(offer->description()->GetContentByName("data") == NULL);
-  EXPECT_TRUE(offer->description()->GetTransportInfoByName("data") == NULL);
+  EXPECT_TRUE(offer->description()->GetContentByName("data") == nullptr);
+  EXPECT_TRUE(offer->description()->GetTransportInfoByName("data") == nullptr);
 }
 
 TEST_P(WebRtcSessionTest, TestCreateAnswerWithSctpInOfferAndNoStreams) {
   SetFactoryDtlsSrtp();
   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.
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
-  EXPECT_TRUE(answer != NULL);
-  EXPECT_TRUE(answer->description()->GetContentByName("data") != NULL);
-  EXPECT_TRUE(answer->description()->GetTransportInfoByName("data") != NULL);
+  EXPECT_TRUE(answer != nullptr);
+  EXPECT_TRUE(answer->description()->GetContentByName("data") != nullptr);
+  EXPECT_TRUE(answer->description()->GetTransportInfoByName("data") != nullptr);
 }
 
 // Test that if DTLS is disabled, we don't end up with an SctpTransport
 // created (or an RtpDataChannel).
 TEST_P(WebRtcSessionTest, TestSctpDataChannelWithoutDtls) {
   configuration_.enable_dtls_srtp = rtc::Optional<bool>(false);
   InitWithDtls(GetParam());
 
   SetLocalDescriptionWithDataChannel();
   EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
@@ skipping 34 matching lines @@
   // 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());
-  ASSERT_TRUE(answer != NULL);
+  ASSERT_TRUE(answer != nullptr);
 
   // 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(nullptr, data_engine_->GetChannel(0));
   CreateDataChannel();
   ASSERT_NE(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
   EXPECT_EQ(
@@ skipping 46 matching lines @@
 // 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) {
   InitWithDtls(GetParam());
 
   EXPECT_TRUE(session_->waiting_for_certificate_for_testing());
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
-  EXPECT_TRUE(offer != NULL);
+  EXPECT_TRUE(offer != nullptr);
   VerifyNoCryptoParams(offer->description(), true);
   VerifyFingerprintStatus(offer->description(), true);
 }
 
 // Verifies that CreateAnswer 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, TestCreateAnswerBeforeIdentityRequestReturnSuccess) {
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
   cricket::MediaSessionOptions options;
   options.recv_video = true;
   std::unique_ptr<JsepSessionDescription> offer(
       CreateRemoteOffer(options, cricket::SEC_DISABLED));
-  ASSERT_TRUE(offer.get() != NULL);
+  ASSERT_TRUE(offer.get() != nullptr);
   SetRemoteDescriptionWithoutError(offer.release());
 
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
-  EXPECT_TRUE(answer != NULL);
+  EXPECT_TRUE(answer != nullptr);
   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) {
   InitWithDtls(GetParam());
 
   EXPECT_TRUE_WAIT(!session_->waiting_for_certificate_for_testing(), 1000);
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
-  EXPECT_TRUE(offer != NULL);
+  EXPECT_TRUE(offer != nullptr);
 }
 
 // Verifies that CreateOffer fails when CreateOffer is called after async
 // identity generation fails.
 TEST_F(WebRtcSessionTest, TestCreateOfferAfterIdentityRequestReturnFailure) {
   InitWithDtlsIdentityGenFail();
 
   EXPECT_TRUE_WAIT(!session_->waiting_for_certificate_for_testing(), 1000);
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
-  EXPECT_TRUE(offer == NULL);
+  EXPECT_TRUE(offer == nullptr);
 }
 
 // Verifies that CreateOffer succeeds when Multiple CreateOffer calls are made
 // before async identity generation is finished.
 TEST_P(WebRtcSessionTest,
        TestMultipleCreateOfferBeforeIdentityRequestReturnSuccess) {
   VerifyMultipleAsyncCreateDescription(GetParam(),
                                        CreateSessionDescriptionRequest::kOffer);
 }
 
@@ skipping 26 matching lines @@
 TEST_F(WebRtcSessionTest, TestSetRemoteOfferFailIfDtlsDisabledAndNoCrypto) {
   // Init without DTLS.
   Init();
   // Create a remote offer with secured transport disabled.
   cricket::MediaSessionOptions options;
   JsepSessionDescription* offer(CreateRemoteOffer(
       options, cricket::SEC_DISABLED));
   // Adds a DTLS fingerprint to the remote offer.
   cricket::SessionDescription* sdp = offer->description();
   TransportInfo* audio = sdp->GetTransportInfoByName("audio");
-  ASSERT_TRUE(audio != NULL);
-  ASSERT_TRUE(audio->description.identity_fingerprint.get() == NULL);
+  ASSERT_TRUE(audio != nullptr);
+  ASSERT_TRUE(audio->description.identity_fingerprint.get() == nullptr);
   audio->description.identity_fingerprint.reset(
       rtc::SSLFingerprint::CreateFromRfc4572(
           rtc::DIGEST_SHA_256, kFakeDtlsFingerprint));
   SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto,
                                        offer);
 }
 
 TEST_F(WebRtcSessionTest, TestCombinedAudioVideoBweConstraint) {
   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);
+  ASSERT_TRUE(voice_channel_ != nullptr);
   const cricket::AudioOptions& audio_options = voice_channel_->options();
   EXPECT_EQ(rtc::Optional<bool>(true), audio_options.combined_audio_video_bwe);
 }
 
 // Tests that we can renegotiate new media content with ICE candidates in the
 // new remote SDP.
 TEST_P(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesInSdp) {
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
@@ skipping 69 matching lines @@
 }
 #endif  // HAVE_QUIC
 
 // Tests that RTX codec is removed from the answer when it isn't supported
 // by local side.
 TEST_F(WebRtcSessionTest, TestRtxRemovedByCreateAnswer) {
   Init();
   SendAudioVideoStream1();
   std::string offer_sdp(kSdpWithRtx);
 
-  SessionDescriptionInterface* offer =
-      CreateSessionDescription(JsepSessionDescription::kOffer, offer_sdp, NULL);
+  SessionDescriptionInterface* offer = CreateSessionDescription(
+      JsepSessionDescription::kOffer, offer_sdp, nullptr);
   EXPECT_TRUE(offer->ToString(&offer_sdp));
 
   // Offer SDP contains the RTX codec.
   EXPECT_TRUE(ContainsVideoCodecWithName(offer, "rtx"));
   SetRemoteDescriptionWithoutError(offer);
 
   SessionDescriptionInterface* answer = CreateAnswer();
   // Answer SDP does not contain the RTX codec.
   EXPECT_FALSE(ContainsVideoCodecWithName(answer, "rtx"));
   SetLocalDescriptionWithoutError(answer);
@@ skipping 81 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));