Replace NULL with nullptr in all C++ files.

webrtc/pc/mediasession_unittest.cc

 /*
  *  Copyright 2004 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 282 matching lines @@
                                              current_video_pwd))));
       EXPECT_TRUE(current_desc->AddTransportInfo(
           TransportInfo("data",
                         TransportDescription(current_data_ufrag,
                                              current_data_pwd))));
     }
     if (offer) {
       desc.reset(f1_.CreateOffer(options, current_desc.get()));
     } else {
       std::unique_ptr<SessionDescription> offer;
-      offer.reset(f1_.CreateOffer(options, NULL));
+      offer.reset(f1_.CreateOffer(options, nullptr));
       desc.reset(f1_.CreateAnswer(offer.get(), options, current_desc.get()));
     }
-    ASSERT_TRUE(desc.get() != NULL);
+    ASSERT_TRUE(desc.get() != nullptr);
     const TransportInfo* ti_audio = desc->GetTransportInfoByName("audio");
     if (options.has_audio()) {
-      EXPECT_TRUE(ti_audio != NULL);
+      EXPECT_TRUE(ti_audio != nullptr);
       if (has_current_desc) {
         EXPECT_EQ(current_audio_ufrag, ti_audio->description.ice_ufrag);
         EXPECT_EQ(current_audio_pwd, ti_audio->description.ice_pwd);
       } else {
         EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
                   ti_audio->description.ice_ufrag.size());
         EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
                   ti_audio->description.ice_pwd.size());
       }
       EXPECT_EQ(options.enable_ice_renomination, GetIceRenomination(ti_audio));
 
     } else {
-      EXPECT_TRUE(ti_audio == NULL);
+      EXPECT_TRUE(ti_audio == nullptr);
     }
     const TransportInfo* ti_video = desc->GetTransportInfoByName("video");
     if (options.has_video()) {
-      EXPECT_TRUE(ti_video != NULL);
+      EXPECT_TRUE(ti_video != nullptr);
       if (options.bundle_enabled) {
         EXPECT_EQ(ti_audio->description.ice_ufrag,
                   ti_video->description.ice_ufrag);
         EXPECT_EQ(ti_audio->description.ice_pwd,
                   ti_video->description.ice_pwd);
       } else {
         if (has_current_desc) {
           EXPECT_EQ(current_video_ufrag, ti_video->description.ice_ufrag);
           EXPECT_EQ(current_video_pwd, ti_video->description.ice_pwd);
         } else {
           EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
                     ti_video->description.ice_ufrag.size());
           EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
                     ti_video->description.ice_pwd.size());
         }
       }
       EXPECT_EQ(options.enable_ice_renomination, GetIceRenomination(ti_video));
     } else {
-      EXPECT_TRUE(ti_video == NULL);
+      EXPECT_TRUE(ti_video == nullptr);
     }
     const TransportInfo* ti_data = desc->GetTransportInfoByName("data");
     if (options.has_data()) {
-      EXPECT_TRUE(ti_data != NULL);
+      EXPECT_TRUE(ti_data != nullptr);
       if (options.bundle_enabled) {
         EXPECT_EQ(ti_audio->description.ice_ufrag,
                   ti_data->description.ice_ufrag);
         EXPECT_EQ(ti_audio->description.ice_pwd,
                   ti_data->description.ice_pwd);
       } else {
         if (has_current_desc) {
           EXPECT_EQ(current_data_ufrag, ti_data->description.ice_ufrag);
           EXPECT_EQ(current_data_pwd, ti_data->description.ice_pwd);
         } else {
           EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
                     ti_data->description.ice_ufrag.size());
           EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
                     ti_data->description.ice_pwd.size());
         }
       }
       EXPECT_EQ(options.enable_ice_renomination, GetIceRenomination(ti_data));
 
     } else {
-      EXPECT_TRUE(ti_video == NULL);
+      EXPECT_TRUE(ti_video == nullptr);
     }
   }
 
   void TestCryptoWithBundle(bool offer) {
     f1_.set_secure(SEC_ENABLED);
     MediaSessionOptions options;
     options.recv_audio = true;
     options.recv_video = true;
     options.data_channel_type = cricket::DCT_RTP;
     std::unique_ptr<SessionDescription> ref_desc;
     std::unique_ptr<SessionDescription> desc;
     if (offer) {
       options.bundle_enabled = false;
-      ref_desc.reset(f1_.CreateOffer(options, NULL));
+      ref_desc.reset(f1_.CreateOffer(options, nullptr));
       options.bundle_enabled = true;
       desc.reset(f1_.CreateOffer(options, ref_desc.get()));
     } else {
       options.bundle_enabled = true;
-      ref_desc.reset(f1_.CreateOffer(options, NULL));
-      desc.reset(f1_.CreateAnswer(ref_desc.get(), options, NULL));
+      ref_desc.reset(f1_.CreateOffer(options, nullptr));
+      desc.reset(f1_.CreateAnswer(ref_desc.get(), options, nullptr));
     }
-    ASSERT_TRUE(desc.get() != NULL);
+    ASSERT_TRUE(desc.get() != nullptr);
     const cricket::MediaContentDescription* audio_media_desc =
         static_cast<const cricket::MediaContentDescription*>(
             desc.get()->GetContentDescriptionByName("audio"));
-    ASSERT_TRUE(audio_media_desc != NULL);
+    ASSERT_TRUE(audio_media_desc != nullptr);
     const cricket::MediaContentDescription* video_media_desc =
         static_cast<const cricket::MediaContentDescription*>(
             desc.get()->GetContentDescriptionByName("video"));
-    ASSERT_TRUE(video_media_desc != NULL);
+    ASSERT_TRUE(video_media_desc != nullptr);
     EXPECT_TRUE(CompareCryptoParams(audio_media_desc->cryptos(),
                                     video_media_desc->cryptos()));
     EXPECT_EQ(1u, audio_media_desc->cryptos().size());
     EXPECT_EQ(std::string(CS_AES_CM_128_HMAC_SHA1_80),
               audio_media_desc->cryptos()[0].cipher_suite);
 
     // Verify the selected crypto is one from the reference audio
     // media content.
     const cricket::MediaContentDescription* ref_audio_media_desc =
         static_cast<const cricket::MediaContentDescription*>(
@@ skipping 10 matching lines @@
   }
 
   // This test that the audio and video media direction is set to
   // |expected_direction_in_answer| in an answer if the offer direction is set
   // to |direction_in_offer|.
   void TestMediaDirectionInAnswer(
       cricket::MediaContentDirection direction_in_offer,
       cricket::MediaContentDirection expected_direction_in_answer) {
     MediaSessionOptions opts;
     opts.recv_video = true;
-    std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-    ASSERT_TRUE(offer.get() != NULL);
+    std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+    ASSERT_TRUE(offer.get() != nullptr);
     ContentInfo* ac_offer = offer->GetContentByName("audio");
-    ASSERT_TRUE(ac_offer != NULL);
+    ASSERT_TRUE(ac_offer != nullptr);
     AudioContentDescription* acd_offer =
         static_cast<AudioContentDescription*>(ac_offer->description);
     acd_offer->set_direction(direction_in_offer);
     ContentInfo* vc_offer = offer->GetContentByName("video");
-    ASSERT_TRUE(vc_offer != NULL);
+    ASSERT_TRUE(vc_offer != nullptr);
     VideoContentDescription* vcd_offer =
         static_cast<VideoContentDescription*>(vc_offer->description);
     vcd_offer->set_direction(direction_in_offer);
 
     std::unique_ptr<SessionDescription> answer(
-        f2_.CreateAnswer(offer.get(), opts, NULL));
+        f2_.CreateAnswer(offer.get(), opts, nullptr));
     const AudioContentDescription* acd_answer =
         GetFirstAudioContentDescription(answer.get());
     EXPECT_EQ(expected_direction_in_answer, acd_answer->direction());
     const VideoContentDescription* vcd_answer =
         GetFirstVideoContentDescription(answer.get());
     EXPECT_EQ(expected_direction_in_answer, vcd_answer->direction());
   }
 
   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 TestVideoGcmCipher(bool gcm_offer, bool gcm_answer) {
     MediaSessionOptions offer_opts;
     offer_opts.recv_video = true;
     offer_opts.crypto_options.enable_gcm_crypto_suites = gcm_offer;
     MediaSessionOptions answer_opts;
     answer_opts.recv_video = true;
     answer_opts.crypto_options.enable_gcm_crypto_suites = gcm_answer;
     f1_.set_secure(SEC_ENABLED);
     f2_.set_secure(SEC_ENABLED);
     std::unique_ptr<SessionDescription> offer(
-        f1_.CreateOffer(offer_opts, NULL));
-    ASSERT_TRUE(offer.get() != NULL);
+        f1_.CreateOffer(offer_opts, nullptr));
+    ASSERT_TRUE(offer.get() != nullptr);
     std::unique_ptr<SessionDescription> answer(
-        f2_.CreateAnswer(offer.get(), answer_opts, NULL));
+        f2_.CreateAnswer(offer.get(), answer_opts, nullptr));
     const ContentInfo* ac = answer->GetContentByName("audio");
     const ContentInfo* vc = answer->GetContentByName("video");
-    ASSERT_TRUE(ac != NULL);
-    ASSERT_TRUE(vc != NULL);
+    ASSERT_TRUE(ac != nullptr);
+    ASSERT_TRUE(vc != nullptr);
     EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
     EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
     const AudioContentDescription* acd =
         static_cast<const AudioContentDescription*>(ac->description);
     const VideoContentDescription* vcd =
         static_cast<const VideoContentDescription*>(vc->description);
     EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
     EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
     EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
     EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
@@ skipping 19 matching lines @@
   MediaSessionDescriptionFactory f1_;
   MediaSessionDescriptionFactory f2_;
   TransportDescriptionFactory tdf1_;
   TransportDescriptionFactory tdf2_;
 };
 
 // Create a typical audio offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOffer) {
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(MediaSessionOptions(), NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+      f1_.CreateOffer(MediaSessionOptions(), nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc == NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc == nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical video offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   f1_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
@@ skipping 17 matching lines @@
   const AudioCodec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
   const DataCodec& offered_data_codec = f2_.data_codecs()[0];
   ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
   ASSERT_EQ(offered_video_codec.id, offered_data_codec.id);
 
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = true;
   opts.data_channel_type = cricket::DCT_RTP;
   opts.bundle_enabled = true;
-  std::unique_ptr<SessionDescription> offer(f2_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f2_.CreateOffer(opts, nullptr));
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(offer.get());
   const AudioContentDescription* acd =
       GetFirstAudioContentDescription(offer.get());
   const DataContentDescription* dcd =
       GetFirstDataContentDescription(offer.get());
-  ASSERT_TRUE(NULL != vcd);
-  ASSERT_TRUE(NULL != acd);
-  ASSERT_TRUE(NULL != dcd);
+  ASSERT_TRUE(nullptr != vcd);
+  ASSERT_TRUE(nullptr != acd);
+  ASSERT_TRUE(nullptr != dcd);
   EXPECT_NE(vcd->codecs()[0].id, acd->codecs()[0].id);
   EXPECT_NE(vcd->codecs()[0].id, dcd->codecs()[0].id);
   EXPECT_NE(acd->codecs()[0].id, dcd->codecs()[0].id);
   EXPECT_EQ(vcd->codecs()[0].name, offered_video_codec.name);
   EXPECT_EQ(acd->codecs()[0].name, offered_audio_codec.name);
   EXPECT_EQ(dcd->codecs()[0].name, offered_data_codec.name);
 }
 
 // Test creating an updated offer with with bundle, audio, video and data
 // after an audio only session has been negotiated.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestCreateUpdatedVideoOfferWithBundle) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = false;
   opts.data_channel_type = cricket::DCT_NONE;
   opts.bundle_enabled = true;
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   MediaSessionOptions updated_opts;
   updated_opts.recv_audio = true;
   updated_opts.recv_video = true;
   updated_opts.data_channel_type = cricket::DCT_RTP;
   updated_opts.bundle_enabled = true;
   std::unique_ptr<SessionDescription> updated_offer(
       f1_.CreateOffer(updated_opts, answer.get()));
 
   const AudioContentDescription* acd =
       GetFirstAudioContentDescription(updated_offer.get());
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(updated_offer.get());
   const DataContentDescription* dcd =
       GetFirstDataContentDescription(updated_offer.get());
-  EXPECT_TRUE(NULL != vcd);
-  EXPECT_TRUE(NULL != acd);
-  EXPECT_TRUE(NULL != dcd);
+  EXPECT_TRUE(nullptr != vcd);
+  EXPECT_TRUE(nullptr != acd);
+  EXPECT_TRUE(nullptr != dcd);
 
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 }
 
 // Create a RTP data offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateRtpDataOffer) {
   MediaSessionOptions opts;
   opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* dc = offer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(dc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(dc != nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), dc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
@@ skipping 10 matching lines @@
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 }
 
 // Create an SCTP data offer with bundle without error.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSctpDataOffer) {
   MediaSessionOptions opts;
   opts.recv_audio = false;
   opts.bundle_enabled = true;
   opts.data_channel_type = cricket::DCT_SCTP;
   f1_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  EXPECT_TRUE(offer.get() != NULL);
-  EXPECT_TRUE(offer->GetContentByName("data") != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  EXPECT_TRUE(offer.get() != nullptr);
+  EXPECT_TRUE(offer->GetContentByName("data") != nullptr);
 }
 
 // Test creating an sctp data channel from an already generated offer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateImplicitSctpDataOffer) {
   MediaSessionOptions opts;
   opts.recv_audio = false;
   opts.bundle_enabled = true;
   opts.data_channel_type = cricket::DCT_SCTP;
   f1_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer1.get() != NULL);
+  std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer1.get() != nullptr);
   const ContentInfo* data = offer1->GetContentByName("data");
-  ASSERT_TRUE(data != NULL);
+  ASSERT_TRUE(data != nullptr);
   const MediaContentDescription* mdesc =
       static_cast<const MediaContentDescription*>(data->description);
   ASSERT_EQ(cricket::kMediaProtocolSctp, mdesc->protocol());
 
   // Now set data_channel_type to 'none' (default) and make sure that the
   // datachannel type that gets generated from the previous offer, is of the
   // same type.
   opts.data_channel_type = cricket::DCT_NONE;
   std::unique_ptr<SessionDescription> offer2(
       f1_.CreateOffer(opts, offer1.get()));
   data = offer2->GetContentByName("data");
-  ASSERT_TRUE(data != NULL);
+  ASSERT_TRUE(data != nullptr);
   mdesc = static_cast<const MediaContentDescription*>(data->description);
   EXPECT_EQ(cricket::kMediaProtocolSctp, mdesc->protocol());
 }
 
 // Create an audio, video offer without legacy StreamParams.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestCreateOfferWithoutLegacyStreams) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   f1_.set_add_legacy_streams(false);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
 
   EXPECT_FALSE(vcd->has_ssrcs());             // No StreamParams.
   EXPECT_FALSE(acd->has_ssrcs());             // No StreamParams.
 }
 
 // Creates an audio+video sendonly offer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSendOnlyOffer) {
   MediaSessionOptions options;
   options.recv_audio = false;
   options.recv_video = false;
   options.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
   options.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   EXPECT_EQ(2u, offer->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer->contents()[0], MEDIA_TYPE_AUDIO));
   EXPECT_TRUE(IsMediaContentOfType(&offer->contents()[1], MEDIA_TYPE_VIDEO));
 
   EXPECT_EQ(cricket::MD_SENDONLY, GetMediaDirection(&offer->contents()[0]));
   EXPECT_EQ(cricket::MD_SENDONLY, GetMediaDirection(&offer->contents()[1]));
 }
 
 // Verifies that the order of the media contents in the current
 // SessionDescription is preserved in the new SessionDescription.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateOfferContentOrder) {
   MediaSessionOptions opts;
   opts.recv_audio = false;
   opts.recv_video = false;
   opts.data_channel_type = cricket::DCT_SCTP;
 
-  std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer1.get() != NULL);
+  std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer1.get() != nullptr);
   EXPECT_EQ(1u, offer1->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer1->contents()[0], MEDIA_TYPE_DATA));
 
   opts.recv_video = true;
   std::unique_ptr<SessionDescription> offer2(
       f1_.CreateOffer(opts, offer1.get()));
-  ASSERT_TRUE(offer2.get() != NULL);
+  ASSERT_TRUE(offer2.get() != nullptr);
   EXPECT_EQ(2u, offer2->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[0], MEDIA_TYPE_DATA));
   EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[1], MEDIA_TYPE_VIDEO));
 
   opts.recv_audio = true;
   std::unique_ptr<SessionDescription> offer3(
       f1_.CreateOffer(opts, offer2.get()));
-  ASSERT_TRUE(offer3.get() != NULL);
+  ASSERT_TRUE(offer3.get() != nullptr);
   EXPECT_EQ(3u, offer3->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[0], MEDIA_TYPE_DATA));
   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[1], MEDIA_TYPE_VIDEO));
   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[2], MEDIA_TYPE_AUDIO));
 
   // Verifies the default order is audio-video-data, so that the previous checks
   // didn't pass by accident.
-  std::unique_ptr<SessionDescription> offer4(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer4.get() != NULL);
+  std::unique_ptr<SessionDescription> offer4(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer4.get() != nullptr);
   EXPECT_EQ(3u, offer4->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[0], MEDIA_TYPE_AUDIO));
   EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[1], MEDIA_TYPE_VIDEO));
   EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[2], MEDIA_TYPE_DATA));
 }
 
 // Create a typical audio answer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswer) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(MediaSessionOptions(), NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+      f1_.CreateOffer(MediaSessionOptions(), nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc == NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc == nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical audio answer with GCM ciphers enabled, and ensure it
 // matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerGcm) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   MediaSessionOptions options;
   options.crypto_options.enable_gcm_crypto_suites = true;
-  std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(options, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), options, NULL));
+      f2_.CreateAnswer(offer.get(), options, nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc == NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc == nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AEAD_AES_256_GCM);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical video answer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswer) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
@@ skipping 23 matching lines @@
 // and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerGcmAnswer) {
   TestVideoGcmCipher(false, true);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswer) {
   MediaSessionOptions opts;
   opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* vcd =
       static_cast<const DataContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(MEDIA_TYPE_DATA, vcd->type());
   EXPECT_EQ(MAKE_VECTOR(kDataCodecsAnswer), vcd->codecs());
   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
   EXPECT_TRUE(vcd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerGcm) {
   MediaSessionOptions opts;
   opts.data_channel_type = cricket::DCT_RTP;
   opts.crypto_options.enable_gcm_crypto_suites = true;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* vcd =
       static_cast<const DataContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AEAD_AES_256_GCM);
   EXPECT_EQ(MEDIA_TYPE_DATA, vcd->type());
   EXPECT_EQ(MAKE_VECTOR(kDataCodecsAnswer), vcd->codecs());
   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
   EXPECT_TRUE(vcd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(vcd, 1U, CS_AEAD_AES_256_GCM);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 }
 
 // Verifies that the order of the media contents in the offer is preserved in
 // the answer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAnswerContentOrder) {
   MediaSessionOptions opts;
 
   // Creates a data only offer.
   opts.recv_audio = false;
   opts.data_channel_type = cricket::DCT_SCTP;
-  std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer1.get() != NULL);
+  std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer1.get() != nullptr);
 
   // Appends audio to the offer.
   opts.recv_audio = true;
   std::unique_ptr<SessionDescription> offer2(
       f1_.CreateOffer(opts, offer1.get()));
-  ASSERT_TRUE(offer2.get() != NULL);
+  ASSERT_TRUE(offer2.get() != nullptr);
 
   // Appends video to the offer.
   opts.recv_video = true;
   std::unique_ptr<SessionDescription> offer3(
       f1_.CreateOffer(opts, offer2.get()));
-  ASSERT_TRUE(offer3.get() != NULL);
+  ASSERT_TRUE(offer3.get() != nullptr);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer3.get(), opts, NULL));
-  ASSERT_TRUE(answer.get() != NULL);
+      f2_.CreateAnswer(offer3.get(), opts, nullptr));
+  ASSERT_TRUE(answer.get() != nullptr);
   EXPECT_EQ(3u, answer->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[0], MEDIA_TYPE_DATA));
   EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[1], MEDIA_TYPE_AUDIO));
   EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[2], MEDIA_TYPE_VIDEO));
 }
 
 // TODO(deadbeef): Extend these tests to ensure the correct direction with other
 // answerer settings.
 
 // This test that the media direction is set to send/receive in an answer if
@@ skipping 21 matching lines @@
 }
 
 // Test that a data content with an unknown protocol is rejected in an answer.
 TEST_F(MediaSessionDescriptionFactoryTest,
        CreateDataAnswerToOfferWithUnknownProtocol) {
   MediaSessionOptions opts;
   opts.data_channel_type = cricket::DCT_RTP;
   opts.recv_audio = false;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   ContentInfo* dc_offer = offer->GetContentByName("data");
-  ASSERT_TRUE(dc_offer != NULL);
+  ASSERT_TRUE(dc_offer != nullptr);
   DataContentDescription* dcd_offer =
       static_cast<DataContentDescription*>(dc_offer->description);
-  ASSERT_TRUE(dcd_offer != NULL);
+  ASSERT_TRUE(dcd_offer != nullptr);
   std::string protocol = "a weird unknown protocol";
   dcd_offer->set_protocol(protocol);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   const ContentInfo* dc_answer = answer->GetContentByName("data");
-  ASSERT_TRUE(dc_answer != NULL);
+  ASSERT_TRUE(dc_answer != nullptr);
   EXPECT_TRUE(dc_answer->rejected);
   const DataContentDescription* dcd_answer =
       static_cast<const DataContentDescription*>(dc_answer->description);
-  ASSERT_TRUE(dcd_answer != NULL);
+  ASSERT_TRUE(dcd_answer != nullptr);
   EXPECT_EQ(protocol, dcd_answer->protocol());
 }
 
 // Test that the media protocol is RTP/AVPF if DTLS and SDES are disabled.
 TEST_F(MediaSessionDescriptionFactoryTest, AudioOfferAnswerWithCryptoDisabled) {
   MediaSessionOptions opts;
   f1_.set_secure(SEC_DISABLED);
   f2_.set_secure(SEC_DISABLED);
   tdf1_.set_secure(SEC_DISABLED);
   tdf2_.set_secure(SEC_DISABLED);
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   const AudioContentDescription* offer_acd =
       GetFirstAudioContentDescription(offer.get());
-  ASSERT_TRUE(offer_acd != NULL);
+  ASSERT_TRUE(offer_acd != nullptr);
   EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf), offer_acd->protocol());
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   const ContentInfo* ac_answer = answer->GetContentByName("audio");
-  ASSERT_TRUE(ac_answer != NULL);
+  ASSERT_TRUE(ac_answer != nullptr);
   EXPECT_FALSE(ac_answer->rejected);
 
   const AudioContentDescription* answer_acd =
       GetFirstAudioContentDescription(answer.get());
-  ASSERT_TRUE(answer_acd != NULL);
+  ASSERT_TRUE(answer_acd != nullptr);
   EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf), answer_acd->protocol());
 }
 
 // Create a video offer and answer and ensure the RTP header extensions
 // matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithRtpExtensions) {
   MediaSessionOptions opts;
   opts.recv_video = true;
 
   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension1));
   f1_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension1));
   f2_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension2));
   f2_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension2));
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtension1),
             GetFirstAudioContentDescription(
                 offer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtension1),
             GetFirstVideoContentDescription(
                 offer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtensionAnswer),
             GetFirstAudioContentDescription(
                 answer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtensionAnswer),
             GetFirstVideoContentDescription(
                 answer.get())->rtp_header_extensions());
 }
 
 // Create an audio, video, data answer without legacy StreamParams.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestCreateAnswerWithoutLegacyStreams) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_add_legacy_streams(false);
   f2_.set_add_legacy_streams(false);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   const ContentInfo* dc = answer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
 
   EXPECT_FALSE(acd->has_ssrcs());  // No StreamParams.
   EXPECT_FALSE(vcd->has_ssrcs());  // No StreamParams.
   EXPECT_FALSE(dcd->has_ssrcs());  // No StreamParams.
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestPartial) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   const ContentInfo* dc = offer->GetContentByName("data");
   AudioContentDescription* acd = const_cast<AudioContentDescription*>(
       static_cast<const AudioContentDescription*>(ac->description));
   VideoContentDescription* vcd = const_cast<VideoContentDescription*>(
       static_cast<const VideoContentDescription*>(vc->description));
   DataContentDescription* dcd = const_cast<DataContentDescription*>(
       static_cast<const DataContentDescription*>(dc->description));
 
@@ skipping 24 matching lines @@
   offer_opts.recv_video = true;
   answer_opts.data_channel_type = cricket::DCT_RTP;
   offer_opts.data_channel_type = cricket::DCT_RTP;
 
   std::unique_ptr<SessionDescription> offer;
   std::unique_ptr<SessionDescription> answer;
 
   offer_opts.rtcp_mux_enabled = true;
   answer_opts.rtcp_mux_enabled = true;
 
-  offer.reset(f1_.CreateOffer(offer_opts, NULL));
-  answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
-  ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
-  ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
-  ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
+  offer.reset(f1_.CreateOffer(offer_opts, nullptr));
+  answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, nullptr));
+  ASSERT_TRUE(nullptr != GetFirstAudioContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstVideoContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstDataContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstAudioContentDescription(answer.get()));
+  ASSERT_TRUE(nullptr != GetFirstVideoContentDescription(answer.get()));
+  ASSERT_TRUE(nullptr != GetFirstDataContentDescription(answer.get()));
   EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
 
   offer_opts.rtcp_mux_enabled = true;
   answer_opts.rtcp_mux_enabled = false;
 
-  offer.reset(f1_.CreateOffer(offer_opts, NULL));
-  answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
-  ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
-  ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
-  ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
+  offer.reset(f1_.CreateOffer(offer_opts, nullptr));
+  answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, nullptr));
+  ASSERT_TRUE(nullptr != GetFirstAudioContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstVideoContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstDataContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstAudioContentDescription(answer.get()));
+  ASSERT_TRUE(nullptr != GetFirstVideoContentDescription(answer.get()));
+  ASSERT_TRUE(nullptr != GetFirstDataContentDescription(answer.get()));
   EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
 
   offer_opts.rtcp_mux_enabled = false;
   answer_opts.rtcp_mux_enabled = true;
 
-  offer.reset(f1_.CreateOffer(offer_opts, NULL));
-  answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
-  ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
-  ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
-  ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
+  offer.reset(f1_.CreateOffer(offer_opts, nullptr));
+  answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, nullptr));
+  ASSERT_TRUE(nullptr != GetFirstAudioContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstVideoContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstDataContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstAudioContentDescription(answer.get()));
+  ASSERT_TRUE(nullptr != GetFirstVideoContentDescription(answer.get()));
+  ASSERT_TRUE(nullptr != GetFirstDataContentDescription(answer.get()));
   EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
 
   offer_opts.rtcp_mux_enabled = false;
   answer_opts.rtcp_mux_enabled = false;
 
-  offer.reset(f1_.CreateOffer(offer_opts, NULL));
-  answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
-  ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
-  ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
-  ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
-  ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
+  offer.reset(f1_.CreateOffer(offer_opts, nullptr));
+  answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, nullptr));
+  ASSERT_TRUE(nullptr != GetFirstAudioContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstVideoContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstDataContentDescription(offer.get()));
+  ASSERT_TRUE(nullptr != GetFirstAudioContentDescription(answer.get()));
+  ASSERT_TRUE(nullptr != GetFirstVideoContentDescription(answer.get()));
+  ASSERT_TRUE(nullptr != GetFirstDataContentDescription(answer.get()));
   EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
 }
 
 // Create an audio-only answer to a video offer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerToVideo) {
   MediaSessionOptions opts;
   opts.recv_video = true;
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
-  ASSERT_TRUE(vc->description != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
+  ASSERT_TRUE(vc->description != nullptr);
   EXPECT_TRUE(vc->rejected);
 }
 
 // Create an audio-only answer to an offer with data.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateNoDataAnswerToDataOffer) {
   MediaSessionOptions opts;
   opts.data_channel_type = cricket::DCT_RTP;
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* dc = answer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(dc != NULL);
-  ASSERT_TRUE(dc->description != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(dc != nullptr);
+  ASSERT_TRUE(dc->description != nullptr);
   EXPECT_TRUE(dc->rejected);
 }
 
 // Create an answer that rejects the contents which are rejected in the offer.
 TEST_F(MediaSessionDescriptionFactoryTest,
        CreateAnswerToOfferWithRejectedMedia) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.data_channel_type = cricket::DCT_RTP;
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   ContentInfo* ac = offer->GetContentByName("audio");
   ContentInfo* vc = offer->GetContentByName("video");
   ContentInfo* dc = offer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
-  ASSERT_TRUE(dc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
+  ASSERT_TRUE(dc != nullptr);
   ac->rejected = true;
   vc->rejected = true;
   dc->rejected = true;
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
   ac = answer->GetContentByName("audio");
   vc = answer->GetContentByName("video");
   dc = answer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
-  ASSERT_TRUE(dc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
+  ASSERT_TRUE(dc != nullptr);
   EXPECT_TRUE(ac->rejected);
   EXPECT_TRUE(vc->rejected);
   EXPECT_TRUE(dc->rejected);
 }
 
 // Create an audio and video offer with:
 // - one video track
 // - two audio tracks
 // - two data tracks
 // and ensure it matches what we expect. Also updates the initial offer by
 // adding a new video track and replaces one of the audio tracks.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
   MediaSessionOptions opts;
   opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
   opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
   opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2, kMediaStream1);
   opts.data_channel_type = cricket::DCT_RTP;
   opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack1, kMediaStream1);
   opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack2, kMediaStream1);
 
   f1_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
 
-  ASSERT_TRUE(offer.get() != NULL);
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   const ContentInfo* dc = offer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
-  ASSERT_TRUE(dc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
+  ASSERT_TRUE(dc != nullptr);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
 
   const StreamParamsVec& audio_streams = acd->streams();
@@ skipping 44 matching lines @@
   // Update the offer. Add a new video track that is not synched to the
   // other tracks and replace audio track 2 with audio track 3.
   opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
   opts.RemoveSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
   opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack3, kMediaStream1);
   opts.RemoveSendStream(MEDIA_TYPE_DATA, kDataTrack2);
   opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack3, kMediaStream1);
   std::unique_ptr<SessionDescription> updated_offer(
       f1_.CreateOffer(opts, offer.get()));
 
-  ASSERT_TRUE(updated_offer.get() != NULL);
+  ASSERT_TRUE(updated_offer.get() != nullptr);
   ac = updated_offer->GetContentByName("audio");
   vc = updated_offer->GetContentByName("video");
   dc = updated_offer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
-  ASSERT_TRUE(dc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
+  ASSERT_TRUE(dc != nullptr);
   const AudioContentDescription* updated_acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* updated_vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   const DataContentDescription* updated_dcd =
       static_cast<const DataContentDescription*>(dc->description);
 
   EXPECT_EQ(acd->type(), updated_acd->type());
   EXPECT_EQ(acd->codecs(), updated_acd->codecs());
   EXPECT_EQ(vcd->type(), updated_vcd->type());
@@ skipping 33 matching lines @@
   // The Expected RTCP CNAME is the default one as we are using the default
   // MediaSessionOptions.
   EXPECT_EQ(updated_data_streams[0].cname, cricket::kDefaultRtcpCname);
 }
 
 // Create an offer with simulcast video stream.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSimulcastVideoOffer) {
   MediaSessionOptions opts;
   const int num_sim_layers = 3;
   opts.AddSendVideoStream(kVideoTrack1, kMediaStream1, num_sim_layers);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
 
-  ASSERT_TRUE(offer.get() != NULL);
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* vc = offer->GetContentByName("video");
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(vc != nullptr);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
 
   const StreamParamsVec& video_streams = vcd->streams();
   ASSERT_EQ(1U, video_streams.size());
   EXPECT_EQ(kVideoTrack1, video_streams[0].id);
   const SsrcGroup* sim_ssrc_group =
       video_streams[0].get_ssrc_group(cricket::kSimSsrcGroupSemantics);
-  ASSERT_TRUE(sim_ssrc_group != NULL);
+  ASSERT_TRUE(sim_ssrc_group != nullptr);
   EXPECT_EQ(static_cast<size_t>(num_sim_layers), sim_ssrc_group->ssrcs.size());
 }
 
 // Create an audio and video answer to a standard video offer with:
 // - one video track
 // - two audio tracks
 // - two data tracks
 // and ensure it matches what we expect. Also updates the initial answer by
 // adding a new video track and removes one of the audio tracks.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) {
   MediaSessionOptions offer_opts;
   offer_opts.recv_video = true;
   offer_opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(offer_opts, NULL));
+  std::unique_ptr<SessionDescription> offer(
+      f1_.CreateOffer(offer_opts, nullptr));
 
   MediaSessionOptions opts;
   opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
   opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
   opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2, kMediaStream1);
   opts.data_channel_type = cricket::DCT_RTP;
   opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack1, kMediaStream1);
   opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack2, kMediaStream1);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
-  ASSERT_TRUE(answer.get() != NULL);
+  ASSERT_TRUE(answer.get() != nullptr);
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   const ContentInfo* dc = answer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
-  ASSERT_TRUE(dc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
+  ASSERT_TRUE(dc != nullptr);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 
@@ skipping 41 matching lines @@
   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
 
   // Update the answer. Add a new video track that is not synched to the
   // other tracks and remove 1 audio track.
   opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
   opts.RemoveSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
   opts.RemoveSendStream(MEDIA_TYPE_DATA, kDataTrack2);
   std::unique_ptr<SessionDescription> updated_answer(
       f2_.CreateAnswer(offer.get(), opts, answer.get()));
 
-  ASSERT_TRUE(updated_answer.get() != NULL);
+  ASSERT_TRUE(updated_answer.get() != nullptr);
   ac = updated_answer->GetContentByName("audio");
   vc = updated_answer->GetContentByName("video");
   dc = updated_answer->GetContentByName("data");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
-  ASSERT_TRUE(dc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
+  ASSERT_TRUE(dc != nullptr);
   const AudioContentDescription* updated_acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* updated_vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   const DataContentDescription* updated_dcd =
       static_cast<const DataContentDescription*>(dc->description);
 
   ASSERT_CRYPTO(updated_acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_TRUE(CompareCryptoParams(acd->cryptos(), updated_acd->cryptos()));
   ASSERT_CRYPTO(updated_vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
@@ skipping 26 matching lines @@
 
 // Create an updated offer after creating an answer to the original offer and
 // verify that the codecs that were part of the original answer are not changed
 // in the updated offer.
 TEST_F(MediaSessionDescriptionFactoryTest,
        RespondentCreatesOfferAfterCreatingAnswer) {
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = true;
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   const AudioContentDescription* acd =
       GetFirstAudioContentDescription(answer.get());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
 
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
   EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
 
   std::unique_ptr<SessionDescription> updated_offer(
@@ skipping 38 matching lines @@
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates rtx for H264 with the payload type |f1_| uses.
   AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates rtx for H264 with the payload type |f2_| uses.
   AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
 
   std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
   AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
               &expected_codecs);
 
   EXPECT_EQ(expected_codecs, vcd->codecs());
 
@@ skipping 20 matching lines @@
        RespondentCreatesOfferWithVideoAndRtxAfterCreatingAudioAnswer) {
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates rtx for H264 with the payload type |f1_| uses.
   AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = false;
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   const AudioContentDescription* acd =
       GetFirstAudioContentDescription(answer.get());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
 
   // Now - let |f2_| add video with RTX and let the payload type the RTX codec
   // reference  be the same as an audio codec that was negotiated in the
   // first offer/answer exchange.
   opts.recv_audio = true;
   opts.recv_video = true;
@@ skipping 77 matching lines @@
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX without associated payload type parameter.
   AddRtxCodec(VideoCodec(126, cricket::kRtxCodecName), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H264 with the payload type |f2_| uses.
   AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   // kCodecParamAssociatedPayloadType will always be added to the offer when RTX
   // is selected. Manually remove kCodecParamAssociatedPayloadType so that it
   // is possible to test that that RTX is dropped when
   // kCodecParamAssociatedPayloadType is missing in the offer.
   VideoContentDescription* desc =
       static_cast<cricket::VideoContentDescription*>(
           offer->GetContentDescriptionByName(cricket::CN_VIDEO));
-  ASSERT_TRUE(desc != NULL);
+  ASSERT_TRUE(desc != nullptr);
   std::vector<VideoCodec> codecs = desc->codecs();
   for (std::vector<VideoCodec>::iterator iter = codecs.begin();
        iter != codecs.end(); ++iter) {
     if (iter->name.find(cricket::kRtxCodecName) == 0) {
       iter->params.clear();
     }
   }
   desc->set_codecs(codecs);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   std::vector<std::string> codec_names =
       GetCodecNames(GetFirstVideoContentDescription(answer.get())->codecs());
   EXPECT_EQ(codec_names.end(), std::find(codec_names.begin(), codec_names.end(),
                                          cricket::kRtxCodecName));
 }
 
 // Test that RTX will be filtered out in the answer if its associated payload
 // type doesn't match the local value.
 TEST_F(MediaSessionDescriptionFactoryTest, FilterOutRtxIfAptDoesntMatch) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.recv_audio = false;
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX for H264 in sender.
   AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H263 in receiver.
   AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[1].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   // Associated payload type doesn't match, therefore, RTX codec is removed in
   // the answer.
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   std::vector<std::string> codec_names =
       GetCodecNames(GetFirstVideoContentDescription(answer.get())->codecs());
   EXPECT_EQ(codec_names.end(), std::find(codec_names.begin(), codec_names.end(),
                                          cricket::kRtxCodecName));
 }
 
 // Test that when multiple RTX codecs are offered, only the matched RTX codec
 // is added in the answer, and the unsupported RTX codec is filtered out.
 TEST_F(MediaSessionDescriptionFactoryTest,
@@ skipping 10 matching lines @@
   AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H264 in receiver.
   AddRtxCodec(VideoCodec::CreateRtxCodec(124, kVideoCodecs2[0].id), &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
   // H264-SVC codec is removed in the answer, therefore, associated RTX codec
   // for H264-SVC should also be removed.
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
   std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
   AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
               &expected_codecs);
 
   EXPECT_EQ(expected_codecs, vcd->codecs());
 }
 
 // Test that after one RTX codec has been negotiated, a new offer can attempt
@@ skipping 42 matching lines @@
   opts.AddSendVideoStream("stream1", "stream1label", 3);
 
   // Use a single real codec, and then add RTX for it.
   std::vector<VideoCodec> f1_codecs;
   f1_codecs.push_back(VideoCodec(97, "H264"));
   AddRtxCodec(VideoCodec::CreateRtxCodec(125, 97), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   // Ensure that the offer has an RTX ssrc for each regular ssrc, and that there
   // is a FID ssrc + grouping for each.
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   VideoContentDescription* desc = static_cast<VideoContentDescription*>(
       offer->GetContentDescriptionByName(cricket::CN_VIDEO));
-  ASSERT_TRUE(desc != NULL);
+  ASSERT_TRUE(desc != nullptr);
   EXPECT_TRUE(desc->multistream());
   const StreamParamsVec& streams = desc->streams();
   // Single stream.
   ASSERT_EQ(1u, streams.size());
   // Stream should have 6 ssrcs: 3 for video, 3 for RTX.
   EXPECT_EQ(6u, streams[0].ssrcs.size());
   // And should have a SIM group for the simulcast.
   EXPECT_TRUE(streams[0].has_ssrc_group("SIM"));
   // And a FID group for RTX.
   EXPECT_TRUE(streams[0].has_ssrc_group("FID"));
@@ skipping 94 matching lines @@
        RespondentCreatesOfferAfterCreatingAnswerWithRtpExtensions) {
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = true;
 
   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension1));
   f1_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension1));
   f2_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension2));
   f2_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension2));
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtensionAnswer),
             GetFirstAudioContentDescription(
                 answer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtensionAnswer),
             GetFirstVideoContentDescription(
                 answer.get())->rtp_header_extensions());
 
   std::unique_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
@@ skipping 30 matching lines @@
 // same ID is used. Also verify that the ID isn't changed when creating an
 // updated offer (this was previously a bug).
 TEST_F(MediaSessionDescriptionFactoryTest, RtpExtensionIdReused) {
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = true;
 
   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension3));
   f1_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension3));
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
 
   // Since the audio extensions used ID 3 for "both_audio_and_video", so should
   // the video extensions.
   const RtpExtension kExpectedVideoRtpExtension[] = {
       kVideoRtpExtension3[0], kAudioRtpExtension3[1],
   };
 
   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtension3),
             GetFirstAudioContentDescription(
                 offer.get())->rtp_header_extensions());
@@ skipping 20 matching lines @@
   AudioContentDescription* acd(new AudioContentDescription());
   acd->set_codecs(MAKE_VECTOR(kAudioCodecs1));
   acd->AddLegacyStream(1);
   source.AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP, acd);
   VideoContentDescription* vcd(new VideoContentDescription());
   vcd->set_codecs(MAKE_VECTOR(kVideoCodecs1));
   vcd->AddLegacyStream(2);
   source.AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP, vcd);
 
   std::unique_ptr<SessionDescription> copy(source.Copy());
-  ASSERT_TRUE(copy.get() != NULL);
+  ASSERT_TRUE(copy.get() != nullptr);
   EXPECT_TRUE(copy->HasGroup(cricket::CN_AUDIO));
   const ContentInfo* ac = copy->GetContentByName("audio");
   const ContentInfo* vc = copy->GetContentByName("video");
-  ASSERT_TRUE(ac != NULL);
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(ac != nullptr);
+  ASSERT_TRUE(vc != nullptr);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd_copy =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(acd->codecs(), acd_copy->codecs());
   EXPECT_EQ(1u, acd->first_ssrc());
 
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const VideoContentDescription* vcd_copy =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(vcd->codecs(), vcd_copy->codecs());
@@ skipping 128 matching lines @@
 // Verifies that creating answer fails if the offer has UDP/TLS/RTP/SAVPF but
 // DTLS is not enabled locally.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestOfferDtlsSavpfWithoutDtlsFailed) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_DISABLED);
   tdf2_.set_secure(SEC_DISABLED);
 
   std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(MediaSessionOptions(), NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+      f1_.CreateOffer(MediaSessionOptions(), nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   ContentInfo* offer_content = offer->GetContentByName("audio");
-  ASSERT_TRUE(offer_content != NULL);
+  ASSERT_TRUE(offer_content != nullptr);
   AudioContentDescription* offer_audio_desc =
       static_cast<AudioContentDescription*>(offer_content->description);
   offer_audio_desc->set_protocol(cricket::kMediaProtocolDtlsSavpf);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
-  ASSERT_TRUE(answer != NULL);
+      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), nullptr));
+  ASSERT_TRUE(answer != nullptr);
   ContentInfo* answer_content = answer->GetContentByName("audio");
-  ASSERT_TRUE(answer_content != NULL);
+  ASSERT_TRUE(answer_content != nullptr);
 
   ASSERT_TRUE(answer_content->rejected);
 }
 
 // Offers UDP/TLS/RTP/SAVPF and verifies the answer can be created and contains
 // UDP/TLS/RTP/SAVPF.
 TEST_F(MediaSessionDescriptionFactoryTest, TestOfferDtlsSavpfCreateAnswer) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_ENABLED);
   tdf2_.set_secure(SEC_ENABLED);
 
   std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(MediaSessionOptions(), NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+      f1_.CreateOffer(MediaSessionOptions(), nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   ContentInfo* offer_content = offer->GetContentByName("audio");
-  ASSERT_TRUE(offer_content != NULL);
+  ASSERT_TRUE(offer_content != nullptr);
   AudioContentDescription* offer_audio_desc =
       static_cast<AudioContentDescription*>(offer_content->description);
   offer_audio_desc->set_protocol(cricket::kMediaProtocolDtlsSavpf);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
-  ASSERT_TRUE(answer != NULL);
+      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), nullptr));
+  ASSERT_TRUE(answer != nullptr);
 
   const ContentInfo* answer_content = answer->GetContentByName("audio");
-  ASSERT_TRUE(answer_content != NULL);
+  ASSERT_TRUE(answer_content != nullptr);
   ASSERT_FALSE(answer_content->rejected);
 
   const AudioContentDescription* answer_audio_desc =
       static_cast<const AudioContentDescription*>(answer_content->description);
   EXPECT_EQ(std::string(cricket::kMediaProtocolDtlsSavpf),
                         answer_audio_desc->protocol());
 }
 
 // Test that we include both SDES and DTLS in the offer, but only include SDES
 // in the answer if DTLS isn't negotiated.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoDtls) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_ENABLED);
   tdf2_.set_secure(SEC_DISABLED);
   MediaSessionOptions options;
   options.recv_audio = true;
   options.recv_video = true;
   std::unique_ptr<SessionDescription> offer, answer;
   const cricket::MediaContentDescription* audio_media_desc;
   const cricket::MediaContentDescription* video_media_desc;
   const cricket::TransportDescription* audio_trans_desc;
   const cricket::TransportDescription* video_trans_desc;
 
   // Generate an offer with SDES and DTLS support.
-  offer.reset(f1_.CreateOffer(options, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  offer.reset(f1_.CreateOffer(options, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
 
   audio_media_desc = static_cast<const cricket::MediaContentDescription*>(
       offer->GetContentDescriptionByName("audio"));
-  ASSERT_TRUE(audio_media_desc != NULL);
+  ASSERT_TRUE(audio_media_desc != nullptr);
   video_media_desc = static_cast<const cricket::MediaContentDescription*>(
       offer->GetContentDescriptionByName("video"));
-  ASSERT_TRUE(video_media_desc != NULL);
+  ASSERT_TRUE(video_media_desc != nullptr);
   EXPECT_EQ(2u, audio_media_desc->cryptos().size());
   EXPECT_EQ(1u, video_media_desc->cryptos().size());
 
   audio_trans_desc = offer->GetTransportDescriptionByName("audio");
-  ASSERT_TRUE(audio_trans_desc != NULL);
+  ASSERT_TRUE(audio_trans_desc != nullptr);
   video_trans_desc = offer->GetTransportDescriptionByName("video");
-  ASSERT_TRUE(video_trans_desc != NULL);
-  ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != NULL);
-  ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != NULL);
+  ASSERT_TRUE(video_trans_desc != nullptr);
+  ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != nullptr);
+  ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != nullptr);
 
   // Generate an answer with only SDES support, since tdf2 has crypto disabled.
-  answer.reset(f2_.CreateAnswer(offer.get(), options, NULL));
-  ASSERT_TRUE(answer.get() != NULL);
+  answer.reset(f2_.CreateAnswer(offer.get(), options, nullptr));
+  ASSERT_TRUE(answer.get() != nullptr);
 
   audio_media_desc = static_cast<const cricket::MediaContentDescription*>(
       answer->GetContentDescriptionByName("audio"));
-  ASSERT_TRUE(audio_media_desc != NULL);
+  ASSERT_TRUE(audio_media_desc != nullptr);
   video_media_desc = static_cast<const cricket::MediaContentDescription*>(
       answer->GetContentDescriptionByName("video"));
-  ASSERT_TRUE(video_media_desc != NULL);
+  ASSERT_TRUE(video_media_desc != nullptr);
   EXPECT_EQ(1u, audio_media_desc->cryptos().size());
   EXPECT_EQ(1u, video_media_desc->cryptos().size());
 
   audio_trans_desc = answer->GetTransportDescriptionByName("audio");
-  ASSERT_TRUE(audio_trans_desc != NULL);
+  ASSERT_TRUE(audio_trans_desc != nullptr);
   video_trans_desc = answer->GetTransportDescriptionByName("video");
-  ASSERT_TRUE(video_trans_desc != NULL);
-  ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() == NULL);
-  ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() == NULL);
+  ASSERT_TRUE(video_trans_desc != nullptr);
+  ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() == nullptr);
+  ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() == nullptr);
 
   // Enable DTLS; the answer should now only have DTLS support.
   tdf2_.set_secure(SEC_ENABLED);
-  answer.reset(f2_.CreateAnswer(offer.get(), options, NULL));
-  ASSERT_TRUE(answer.get() != NULL);
+  answer.reset(f2_.CreateAnswer(offer.get(), options, nullptr));
+  ASSERT_TRUE(answer.get() != nullptr);
 
   audio_media_desc = static_cast<const cricket::MediaContentDescription*>(
       answer->GetContentDescriptionByName("audio"));
-  ASSERT_TRUE(audio_media_desc != NULL);
+  ASSERT_TRUE(audio_media_desc != nullptr);
   video_media_desc = static_cast<const cricket::MediaContentDescription*>(
       answer->GetContentDescriptionByName("video"));
-  ASSERT_TRUE(video_media_desc != NULL);
+  ASSERT_TRUE(video_media_desc != nullptr);
   EXPECT_TRUE(audio_media_desc->cryptos().empty());
   EXPECT_TRUE(video_media_desc->cryptos().empty());
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
             audio_media_desc->protocol());
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
             video_media_desc->protocol());
 
   audio_trans_desc = answer->GetTransportDescriptionByName("audio");
-  ASSERT_TRUE(audio_trans_desc != NULL);
+  ASSERT_TRUE(audio_trans_desc != nullptr);
   video_trans_desc = answer->GetTransportDescriptionByName("video");
-  ASSERT_TRUE(video_trans_desc != NULL);
-  ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != NULL);
-  ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != NULL);
+  ASSERT_TRUE(video_trans_desc != nullptr);
+  ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != nullptr);
+  ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != nullptr);
 
   // Try creating offer again. DTLS enabled now, crypto's should be empty
   // in new offer.
   offer.reset(f1_.CreateOffer(options, offer.get()));
-  ASSERT_TRUE(offer.get() != NULL);
+  ASSERT_TRUE(offer.get() != nullptr);
   audio_media_desc = static_cast<const cricket::MediaContentDescription*>(
       offer->GetContentDescriptionByName("audio"));
-  ASSERT_TRUE(audio_media_desc != NULL);
+  ASSERT_TRUE(audio_media_desc != nullptr);
   video_media_desc = static_cast<const cricket::MediaContentDescription*>(
       offer->GetContentDescriptionByName("video"));
-  ASSERT_TRUE(video_media_desc != NULL);
+  ASSERT_TRUE(video_media_desc != nullptr);
   EXPECT_TRUE(audio_media_desc->cryptos().empty());
   EXPECT_TRUE(video_media_desc->cryptos().empty());
 
   audio_trans_desc = offer->GetTransportDescriptionByName("audio");
-  ASSERT_TRUE(audio_trans_desc != NULL);
+  ASSERT_TRUE(audio_trans_desc != nullptr);
   video_trans_desc = offer->GetTransportDescriptionByName("video");
-  ASSERT_TRUE(video_trans_desc != NULL);
-  ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != NULL);
-  ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != NULL);
+  ASSERT_TRUE(video_trans_desc != nullptr);
+  ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != nullptr);
+  ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != nullptr);
 }
 
 // Test that an answer can't be created if cryptos are required but the offer is
 // unsecure.
 TEST_F(MediaSessionDescriptionFactoryTest, TestSecureAnswerToUnsecureOffer) {
   MediaSessionOptions options;
   f1_.set_secure(SEC_DISABLED);
   tdf1_.set_secure(SEC_DISABLED);
   f2_.set_secure(SEC_REQUIRED);
   tdf1_.set_secure(SEC_ENABLED);
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), options, NULL));
-  EXPECT_TRUE(answer.get() == NULL);
+      f2_.CreateAnswer(offer.get(), options, nullptr));
+  EXPECT_TRUE(answer.get() == nullptr);
 }
 
 // Test that we accept a DTLS offer without SDES and create an appropriate
 // answer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoOfferDtlsButNotSdes) {
   f1_.set_secure(SEC_DISABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_ENABLED);
   tdf2_.set_secure(SEC_ENABLED);
   MediaSessionOptions options;
   options.recv_audio = true;
   options.recv_video = true;
   options.data_channel_type = cricket::DCT_RTP;
 
   std::unique_ptr<SessionDescription> offer, answer;
 
   // Generate an offer with DTLS but without SDES.
-  offer.reset(f1_.CreateOffer(options, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  offer.reset(f1_.CreateOffer(options, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
 
   const AudioContentDescription* audio_offer =
       GetFirstAudioContentDescription(offer.get());
   ASSERT_TRUE(audio_offer->cryptos().empty());
   const VideoContentDescription* video_offer =
       GetFirstVideoContentDescription(offer.get());
   ASSERT_TRUE(video_offer->cryptos().empty());
   const DataContentDescription* data_offer =
       GetFirstDataContentDescription(offer.get());
   ASSERT_TRUE(data_offer->cryptos().empty());
 
   const cricket::TransportDescription* audio_offer_trans_desc =
       offer->GetTransportDescriptionByName("audio");
-  ASSERT_TRUE(audio_offer_trans_desc->identity_fingerprint.get() != NULL);
+  ASSERT_TRUE(audio_offer_trans_desc->identity_fingerprint.get() != nullptr);
   const cricket::TransportDescription* video_offer_trans_desc =
       offer->GetTransportDescriptionByName("video");
-  ASSERT_TRUE(video_offer_trans_desc->identity_fingerprint.get() != NULL);
+  ASSERT_TRUE(video_offer_trans_desc->identity_fingerprint.get() != nullptr);
   const cricket::TransportDescription* data_offer_trans_desc =
       offer->GetTransportDescriptionByName("data");
-  ASSERT_TRUE(data_offer_trans_desc->identity_fingerprint.get() != NULL);
+  ASSERT_TRUE(data_offer_trans_desc->identity_fingerprint.get() != nullptr);
 
   // Generate an answer with DTLS.
-  answer.reset(f2_.CreateAnswer(offer.get(), options, NULL));
-  ASSERT_TRUE(answer.get() != NULL);
+  answer.reset(f2_.CreateAnswer(offer.get(), options, nullptr));
+  ASSERT_TRUE(answer.get() != nullptr);
 
   const cricket::TransportDescription* audio_answer_trans_desc =
       answer->GetTransportDescriptionByName("audio");
-  EXPECT_TRUE(audio_answer_trans_desc->identity_fingerprint.get() != NULL);
+  EXPECT_TRUE(audio_answer_trans_desc->identity_fingerprint.get() != nullptr);
   const cricket::TransportDescription* video_answer_trans_desc =
       answer->GetTransportDescriptionByName("video");
-  EXPECT_TRUE(video_answer_trans_desc->identity_fingerprint.get() != NULL);
+  EXPECT_TRUE(video_answer_trans_desc->identity_fingerprint.get() != nullptr);
   const cricket::TransportDescription* data_answer_trans_desc =
       answer->GetTransportDescriptionByName("data");
-  EXPECT_TRUE(data_answer_trans_desc->identity_fingerprint.get() != NULL);
+  EXPECT_TRUE(data_answer_trans_desc->identity_fingerprint.get() != nullptr);
 }
 
 // Verifies if vad_enabled option is set to false, CN codecs are not present in
 // offer or answer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestVADEnableOption) {
   MediaSessionOptions options;
   options.recv_audio = true;
   options.recv_video = true;
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* audio_content = offer->GetContentByName("audio");
   EXPECT_FALSE(VerifyNoCNCodecs(audio_content));
 
   options.vad_enabled = false;
-  offer.reset(f1_.CreateOffer(options, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  offer.reset(f1_.CreateOffer(options, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   audio_content = offer->GetContentByName("audio");
   EXPECT_TRUE(VerifyNoCNCodecs(audio_content));
   std::unique_ptr<SessionDescription> answer(
-      f1_.CreateAnswer(offer.get(), options, NULL));
-  ASSERT_TRUE(answer.get() != NULL);
+      f1_.CreateAnswer(offer.get(), options, nullptr));
+  ASSERT_TRUE(answer.get() != nullptr);
   audio_content = answer->GetContentByName("audio");
   EXPECT_TRUE(VerifyNoCNCodecs(audio_content));
 }
 
 // Test that the content name ("mid" in SDP) is unchanged when creating a
 // new offer.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestContentNameNotChangedInSubsequentOffers) {
   MediaSessionOptions opts;
   opts.recv_audio = true;
@@ skipping 143 matching lines @@
   sf.set_audio_codecs(send_codecs, recv_codecs);
   sf.set_add_legacy_streams(add_legacy_stream);
 
   MediaSessionOptions opts;
   opts.recv_audio = (direction == cricket::MD_RECVONLY ||
                      direction == cricket::MD_SENDRECV);
   opts.recv_video = false;
   if (direction == cricket::MD_SENDONLY || direction == cricket::MD_SENDRECV)
     opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
 
-  std::unique_ptr<SessionDescription> offer(sf.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+  std::unique_ptr<SessionDescription> offer(sf.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
   const ContentInfo* ac = offer->GetContentByName("audio");
 
   // If the factory didn't add any audio content to the offer, we cannot check
   // that the codecs put in are right. This happens when we neither want to send
   // nor receive audio. The checks are still in place if at some point we'd
   // instead create an inactive stream.
   if (ac) {
     AudioContentDescription* acd =
         static_cast<AudioContentDescription*>(ac->description);
     // sendrecv and inactive should both present lists as if the channel was to
@@ skipping 83 matching lines @@
   MediaSessionOptions offer_opts;
   offer_opts.recv_audio = (offer_direction == cricket::MD_RECVONLY ||
                            offer_direction == cricket::MD_SENDRECV);
   offer_opts.recv_video = false;
   if (offer_direction == cricket::MD_SENDONLY ||
       offer_direction == cricket::MD_SENDRECV) {
     offer_opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
   }
 
   std::unique_ptr<SessionDescription> offer(
-      offer_factory.CreateOffer(offer_opts, NULL));
-  ASSERT_TRUE(offer.get() != NULL);
+      offer_factory.CreateOffer(offer_opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
 
   MediaSessionOptions answer_opts;
   answer_opts.recv_audio = (answer_direction == cricket::MD_RECVONLY ||
                             answer_direction == cricket::MD_SENDRECV);
   answer_opts.recv_video = false;
   if (answer_direction == cricket::MD_SENDONLY ||
       answer_direction == cricket::MD_SENDRECV) {
     answer_opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
   }
   std::unique_ptr<SessionDescription> answer(
-      answer_factory.CreateAnswer(offer.get(), answer_opts, NULL));
+      answer_factory.CreateAnswer(offer.get(), answer_opts, nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
 
   // If the factory didn't add any audio content to the answer, we cannot check
   // that the codecs put in are right. This happens when we neither want to send
   // nor receive audio. The checks are still in place if at some point we'd
   // instead create an inactive stream.
   if (ac) {
     const AudioContentDescription* acd =
         static_cast<const AudioContentDescription*>(ac->description);
     EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
@@ skipping 92 matching lines @@
                         ::testing::Combine(
                              ::testing::Values(cricket::MD_SENDONLY,
                                                cricket::MD_RECVONLY,
                                                cricket::MD_SENDRECV,
                                                cricket::MD_INACTIVE),
                              ::testing::Values(cricket::MD_SENDONLY,
                                                cricket::MD_RECVONLY,
                                                cricket::MD_SENDRECV,
                                                cricket::MD_INACTIVE),
                              ::testing::Bool()));