Replace NULL with nullptr in all C++ files.

webrtc/pc/channel_unittest.cc

 /*
  *  Copyright 2009 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 102 matching lines @@
     if (network_is_worker == NetworkIsWorker::Yes) {
       network_thread_ = rtc::Thread::Current();
     } else {
       network_thread_keeper_ = rtc::Thread::Create();
       network_thread_keeper_->SetName("Network", nullptr);
       network_thread_ = network_thread_keeper_.get();
     }
   }
 
   void CreateChannels(int flags1, int flags2) {
-    CreateChannels(new typename T::MediaChannel(NULL, typename T::Options()),
-                   new typename T::MediaChannel(NULL, typename T::Options()),
+    CreateChannels(new typename T::MediaChannel(nullptr, typename T::Options()),
+                   new typename T::MediaChannel(nullptr, typename T::Options()),
                    flags1, flags2);
   }
   void CreateChannels(typename T::MediaChannel* ch1,
                       typename T::MediaChannel* ch2,
                       int flags1,
                       int flags2) {
     // Network thread is started in CreateChannels, to allow the test to
     // configure a fake clock before any threads are spawned and attempt to
     // access the time.
     if (network_thread_keeper_) {
@@ skipping 131 matching lines @@
     rtc::CryptoOptions crypto_options;
     crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
     channel->SetCryptoOptions(crypto_options);
     if (!channel->NeedsRtcpTransport()) {
       fake_rtcp_dtls_transport = nullptr;
     }
     if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
                          fake_rtp_packet_transport,
                          fake_rtcp_packet_transport)) {
       delete channel;
-      channel = NULL;
+      channel = nullptr;
     }
     return channel;
   }
 
   void ConnectFakeTransports() {
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
       bool asymmetric = false;
       // Depending on test flags, could be using DTLS or raw packet transport.
       if (fake_rtp_dtls_transport1_ && fake_rtp_dtls_transport2_) {
         fake_rtp_dtls_transport1_->SetDestination(
             fake_rtp_dtls_transport2_.get(), asymmetric);
       }
       if (fake_rtcp_dtls_transport1_ && fake_rtcp_dtls_transport2_) {
         fake_rtcp_dtls_transport1_->SetDestination(
             fake_rtcp_dtls_transport2_.get(), asymmetric);
       }
       if (fake_rtp_packet_transport1_ && fake_rtp_packet_transport2_) {
         fake_rtp_packet_transport1_->SetDestination(
             fake_rtp_packet_transport2_.get(), asymmetric);
       }
       if (fake_rtcp_packet_transport1_ && fake_rtcp_packet_transport2_) {
         fake_rtcp_packet_transport1_->SetDestination(
             fake_rtcp_packet_transport2_.get(), asymmetric);
       }
     });
   }
 
   bool SendInitiate() {
-    bool result = channel1_->SetLocalContent(&local_media_content1_,
-                                             CA_OFFER, NULL);
+    bool result =
+        channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, nullptr);
     if (result) {
       channel1_->Enable(true);
-      result = channel2_->SetRemoteContent(&remote_media_content1_,
-                                           CA_OFFER, NULL);
+      result = channel2_->SetRemoteContent(&remote_media_content1_, CA_OFFER,
+                                           nullptr);
       if (result) {
         ConnectFakeTransports();
-        result = channel2_->SetLocalContent(&local_media_content2_,
-                                            CA_ANSWER, NULL);
+        result = channel2_->SetLocalContent(&local_media_content2_, CA_ANSWER,
+                                            nullptr);
       }
     }
     return result;
   }
 
   bool SendAccept() {
     channel2_->Enable(true);
-    return channel1_->SetRemoteContent(&remote_media_content2_,
-                                       CA_ANSWER, NULL);
+    return channel1_->SetRemoteContent(&remote_media_content2_, CA_ANSWER,
+                                       nullptr);
   }
 
   bool SendOffer() {
-    bool result = channel1_->SetLocalContent(&local_media_content1_,
-                                             CA_OFFER, NULL);
+    bool result =
+        channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, nullptr);
     if (result) {
       channel1_->Enable(true);
-      result = channel2_->SetRemoteContent(&remote_media_content1_,
-                                           CA_OFFER, NULL);
+      result = channel2_->SetRemoteContent(&remote_media_content1_, CA_OFFER,
+                                           nullptr);
     }
     return result;
   }
 
   bool SendProvisionalAnswer() {
     bool result = channel2_->SetLocalContent(&local_media_content2_,
-                                             CA_PRANSWER, NULL);
+                                             CA_PRANSWER, nullptr);
     if (result) {
       channel2_->Enable(true);
-      result = channel1_->SetRemoteContent(&remote_media_content2_,
-                                           CA_PRANSWER, NULL);
+      result = channel1_->SetRemoteContent(&remote_media_content2_, CA_PRANSWER,
+                                           nullptr);
       ConnectFakeTransports();
     }
     return result;
   }
 
   bool SendFinalAnswer() {
-    bool result = channel2_->SetLocalContent(&local_media_content2_,
-                                             CA_ANSWER, NULL);
+    bool result =
+        channel2_->SetLocalContent(&local_media_content2_, CA_ANSWER, nullptr);
     if (result)
-      result = channel1_->SetRemoteContent(&remote_media_content2_,
-                                           CA_ANSWER, NULL);
+      result = channel1_->SetRemoteContent(&remote_media_content2_, CA_ANSWER,
+                                           nullptr);
     return result;
   }
 
   bool Terminate() {
     channel1_.reset();
     channel2_.reset();
     fake_rtp_dtls_transport1_.reset();
     fake_rtcp_dtls_transport1_.reset();
     fake_rtp_dtls_transport2_.reset();
     fake_rtcp_dtls_transport2_.reset();
@@ skipping 215 matching lines @@
     EXPECT_TRUE(media_channel1_->rtp_packets().empty());
     EXPECT_TRUE(media_channel1_->rtcp_packets().empty());
   }
 
   // Test that SetLocalContent and SetRemoteContent properly configure
   // the codecs.
   void TestSetContents() {
     CreateChannels(0, 0);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, nullptr));
     EXPECT_EQ(0U, media_channel1_->codecs().size());
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, nullptr));
     ASSERT_EQ(1U, media_channel1_->codecs().size());
     EXPECT_TRUE(CodecMatches(content.codecs()[0],
                              media_channel1_->codecs()[0]));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly deals
   // with an empty offer.
   void TestSetContentsNullOffer() {
     CreateChannels(0, 0);
     typename T::Content content;
-    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, nullptr));
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     EXPECT_EQ(0U, media_channel1_->codecs().size());
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, nullptr));
     ASSERT_EQ(1U, media_channel1_->codecs().size());
     EXPECT_TRUE(CodecMatches(content.codecs()[0],
                              media_channel1_->codecs()[0]));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly set RTCP
   // mux.
   void TestSetContentsRtcpMux() {
     CreateChannels(0, 0);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     // Both sides agree on mux. Should no longer be a separate RTCP channel.
     content.set_rtcp_mux(true);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, nullptr));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, nullptr));
     // Only initiator supports mux. Should still have a separate RTCP channel.
-    EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, NULL));
+    EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, nullptr));
     content.set_rtcp_mux(false);
-    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, nullptr));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly set RTCP
   // mux when a provisional answer is received.
   void TestSetContentsRtcpMuxWithPrAnswer() {
     CreateChannels(0, 0);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     content.set_rtcp_mux(true);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_PRANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, nullptr));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_PRANSWER, nullptr));
     // Both sides agree on mux. Should signal RTCP mux as fully activated.
     EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, nullptr));
     EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
     // Only initiator supports mux. Should still have a separate RTCP channel.
-    EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, NULL));
+    EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, nullptr));
     content.set_rtcp_mux(false);
-    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_PRANSWER, NULL));
-    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_PRANSWER, nullptr));
+    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, nullptr));
     EXPECT_EQ(0, rtcp_mux_activated_callbacks2_);
   }
 
   // Test that SetRemoteContent properly deals with a content update.
   void TestSetRemoteContentUpdate() {
     CreateChannels(0, 0);
     typename T::Content content;
     CreateContent(RTCP_MUX | SECURE, kPcmuCodec, kH264Codec, &content);
     EXPECT_EQ(0U, media_channel1_->codecs().size());
-    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, nullptr));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, nullptr));
     ASSERT_EQ(1U, media_channel1_->codecs().size());
     EXPECT_TRUE(CodecMatches(content.codecs()[0],
                              media_channel1_->codecs()[0]));
     // Now update with other codecs.
     typename T::Content update_content;
     update_content.set_partial(true);
     CreateContent(0, kIsacCodec, kH264SvcCodec,
                   &update_content);
-    EXPECT_TRUE(channel1_->SetRemoteContent(&update_content, CA_UPDATE, NULL));
+    EXPECT_TRUE(
+        channel1_->SetRemoteContent(&update_content, CA_UPDATE, nullptr));
     ASSERT_EQ(1U, media_channel1_->codecs().size());
     EXPECT_TRUE(CodecMatches(update_content.codecs()[0],
                              media_channel1_->codecs()[0]));
     // Now update without any codecs. This is ignored.
     typename T::Content empty_content;
     empty_content.set_partial(true);
-    EXPECT_TRUE(channel1_->SetRemoteContent(&empty_content, CA_UPDATE, NULL));
+    EXPECT_TRUE(
+        channel1_->SetRemoteContent(&empty_content, CA_UPDATE, nullptr));
     ASSERT_EQ(1U, media_channel1_->codecs().size());
     EXPECT_TRUE(CodecMatches(update_content.codecs()[0],
                              media_channel1_->codecs()[0]));
   }
 
   // Test that Add/RemoveStream properly forward to the media channel.
   void TestStreams() {
     CreateChannels(0, 0);
     EXPECT_TRUE(AddStream1(1));
     EXPECT_TRUE(AddStream1(2));
@@ skipping 25 matching lines @@
     stream3.groupid = "group3";
     stream3.id = "stream3";
     stream3.ssrcs.push_back(kSsrc3);
     stream3.cname = "stream3_cname";
 
     CreateChannels(0, 0);
     typename T::Content content1;
     CreateContent(0, kPcmuCodec, kH264Codec, &content1);
     content1.AddStream(stream1);
     EXPECT_EQ(0u, media_channel1_->send_streams().size());
-    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, nullptr));
 
     ASSERT_EQ(1u, media_channel1_->send_streams().size());
     EXPECT_EQ(stream1, media_channel1_->send_streams()[0]);
 
     // Update the local streams by adding another sending stream.
     // Use a partial updated session description.
     typename T::Content content2;
     content2.AddStream(stream2);
     content2.AddStream(stream3);
     content2.set_partial(true);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content2, CA_UPDATE, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content2, CA_UPDATE, nullptr));
     ASSERT_EQ(3u, media_channel1_->send_streams().size());
     EXPECT_EQ(stream1, media_channel1_->send_streams()[0]);
     EXPECT_EQ(stream2, media_channel1_->send_streams()[1]);
     EXPECT_EQ(stream3, media_channel1_->send_streams()[2]);
 
     // Update the local streams by removing the first sending stream.
     // This is done by removing all SSRCS for this particular stream.
     typename T::Content content3;
     stream1.ssrcs.clear();
     content3.AddStream(stream1);
     content3.set_partial(true);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content3, CA_UPDATE, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content3, CA_UPDATE, nullptr));
     ASSERT_EQ(2u, media_channel1_->send_streams().size());
     EXPECT_EQ(stream2, media_channel1_->send_streams()[0]);
     EXPECT_EQ(stream3, media_channel1_->send_streams()[1]);
 
     // Update the local streams with a stream that does not change.
     // THe update is ignored.
     typename T::Content content4;
     content4.AddStream(stream2);
     content4.set_partial(true);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_UPDATE, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_UPDATE, nullptr));
     ASSERT_EQ(2u, media_channel1_->send_streams().size());
     EXPECT_EQ(stream2, media_channel1_->send_streams()[0]);
     EXPECT_EQ(stream3, media_channel1_->send_streams()[1]);
   }
 
   // Test that SetRemoteContent properly handles adding and removing
   // StreamParams to the remote content description.
   // This test uses the CA_UPDATE action that don't require a full
   // MediaContentDescription to do an update.
   void TestUpdateStreamsInRemoteContent() {
@@ skipping 13 matching lines @@
     stream3.id = "Stream3";
     stream3.groupid = "3";
     stream3.ssrcs.push_back(kSsrc3);
     stream3.cname = "stream3_cname";
 
     CreateChannels(0, 0);
     typename T::Content content1;
     CreateContent(0, kPcmuCodec, kH264Codec, &content1);
     content1.AddStream(stream1);
     EXPECT_EQ(0u, media_channel1_->recv_streams().size());
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content1, CA_OFFER, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content1, CA_OFFER, nullptr));
 
     ASSERT_EQ(1u, media_channel1_->codecs().size());
     ASSERT_EQ(1u, media_channel1_->recv_streams().size());
     EXPECT_EQ(stream1, media_channel1_->recv_streams()[0]);
 
     // Update the remote streams by adding another sending stream.
     // Use a partial updated session description.
     typename T::Content content2;
     content2.AddStream(stream2);
     content2.AddStream(stream3);
     content2.set_partial(true);
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_UPDATE, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_UPDATE, nullptr));
     ASSERT_EQ(3u, media_channel1_->recv_streams().size());
     EXPECT_EQ(stream1, media_channel1_->recv_streams()[0]);
     EXPECT_EQ(stream2, media_channel1_->recv_streams()[1]);
     EXPECT_EQ(stream3, media_channel1_->recv_streams()[2]);
 
     // Update the remote streams by removing the first stream.
     // This is done by removing all SSRCS for this particular stream.
     typename T::Content content3;
     stream1.ssrcs.clear();
     content3.AddStream(stream1);
     content3.set_partial(true);
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_UPDATE, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_UPDATE, nullptr));
     ASSERT_EQ(2u, media_channel1_->recv_streams().size());
     EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
     EXPECT_EQ(stream3, media_channel1_->recv_streams()[1]);
 
     // Update the remote streams with a stream that does not change.
     // The update is ignored.
     typename T::Content content4;
     content4.AddStream(stream2);
     content4.set_partial(true);
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content4, CA_UPDATE, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content4, CA_UPDATE, nullptr));
     ASSERT_EQ(2u, media_channel1_->recv_streams().size());
     EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
     EXPECT_EQ(stream3, media_channel1_->recv_streams()[1]);
   }
 
   // Test that SetLocalContent and SetRemoteContent properly
   // handles adding and removing StreamParams when the action is a full
   // CA_OFFER / CA_ANSWER.
   void TestChangeStreamParamsInContent() {
     cricket::StreamParams stream1;
     stream1.groupid = "group1";
     stream1.id = "stream1";
     stream1.ssrcs.push_back(kSsrc1);
     stream1.cname = "stream1_cname";
 
     cricket::StreamParams stream2;
     stream2.groupid = "group1";
     stream2.id = "stream2";
     stream2.ssrcs.push_back(kSsrc2);
     stream2.cname = "stream2_cname";
 
     // Setup a call where channel 1 send |stream1| to channel 2.
     CreateChannels(0, 0);
     typename T::Content content1;
     CreateContent(0, kPcmuCodec, kH264Codec, &content1);
     content1.AddStream(stream1);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, nullptr));
     EXPECT_TRUE(channel1_->Enable(true));
     EXPECT_EQ(1u, media_channel1_->send_streams().size());
 
-    EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER, NULL));
+    EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER, nullptr));
     EXPECT_EQ(1u, media_channel2_->recv_streams().size());
     ConnectFakeTransports();
 
     // Channel 2 do not send anything.
     typename T::Content content2;
     CreateContent(0, kPcmuCodec, kH264Codec, &content2);
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER, nullptr));
     EXPECT_EQ(0u, media_channel1_->recv_streams().size());
-    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER, nullptr));
     EXPECT_TRUE(channel2_->Enable(true));
     EXPECT_EQ(0u, media_channel2_->send_streams().size());
 
     SendCustomRtp1(kSsrc1, 0);
     WaitForThreads();
     EXPECT_TRUE(CheckCustomRtp2(kSsrc1, 0));
 
     // Let channel 2 update the content by sending |stream2| and enable SRTP.
     typename T::Content content3;
     CreateContent(SECURE, kPcmuCodec, kH264Codec, &content3);
     content3.AddStream(stream2);
-    EXPECT_TRUE(channel2_->SetLocalContent(&content3, CA_OFFER, NULL));
+    EXPECT_TRUE(channel2_->SetLocalContent(&content3, CA_OFFER, nullptr));
     ASSERT_EQ(1u, media_channel2_->send_streams().size());
     EXPECT_EQ(stream2, media_channel2_->send_streams()[0]);
 
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_OFFER, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_OFFER, nullptr));
     ASSERT_EQ(1u, media_channel1_->recv_streams().size());
     EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
 
     // Channel 1 replies but stop sending stream1.
     typename T::Content content4;
     CreateContent(SECURE, kPcmuCodec, kH264Codec, &content4);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_ANSWER, nullptr));
     EXPECT_EQ(0u, media_channel1_->send_streams().size());
 
-    EXPECT_TRUE(channel2_->SetRemoteContent(&content4, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel2_->SetRemoteContent(&content4, CA_ANSWER, nullptr));
     EXPECT_EQ(0u, media_channel2_->recv_streams().size());
 
     EXPECT_TRUE(channel1_->secure());
     EXPECT_TRUE(channel2_->secure());
     SendCustomRtp2(kSsrc2, 0);
     WaitForThreads();
     EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
   }
 
   // Test that we only start playout and sending at the right times.
   void TestPlayoutAndSendingStates() {
     CreateChannels(0, 0);
     if (verify_playout_) {
       EXPECT_FALSE(media_channel1_->playout());
     }
     EXPECT_FALSE(media_channel1_->sending());
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2_->playout());
     }
     EXPECT_FALSE(media_channel2_->sending());
     EXPECT_TRUE(channel1_->Enable(true));
     if (verify_playout_) {
       EXPECT_FALSE(media_channel1_->playout());
     }
     EXPECT_FALSE(media_channel1_->sending());
-    EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_,
-                                           CA_OFFER, NULL));
+    EXPECT_TRUE(
+        channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, nullptr));
     if (verify_playout_) {
       EXPECT_TRUE(media_channel1_->playout());
     }
     EXPECT_FALSE(media_channel1_->sending());
-    EXPECT_TRUE(channel2_->SetRemoteContent(&local_media_content1_,
-                                            CA_OFFER, NULL));
+    EXPECT_TRUE(
+        channel2_->SetRemoteContent(&local_media_content1_, CA_OFFER, nullptr));
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2_->playout());
     }
     EXPECT_FALSE(media_channel2_->sending());
-    EXPECT_TRUE(channel2_->SetLocalContent(&local_media_content2_,
-                                           CA_ANSWER, NULL));
+    EXPECT_TRUE(
+        channel2_->SetLocalContent(&local_media_content2_, CA_ANSWER, nullptr));
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2_->playout());
     }
     EXPECT_FALSE(media_channel2_->sending());
     ConnectFakeTransports();
     if (verify_playout_) {
       EXPECT_TRUE(media_channel1_->playout());
     }
     EXPECT_FALSE(media_channel1_->sending());
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2_->playout());
     }
     EXPECT_FALSE(media_channel2_->sending());
     EXPECT_TRUE(channel2_->Enable(true));
     if (verify_playout_) {
       EXPECT_TRUE(media_channel2_->playout());
     }
     EXPECT_TRUE(media_channel2_->sending());
-    EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_,
-                                            CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_, CA_ANSWER,
+                                            nullptr));
     if (verify_playout_) {
       EXPECT_TRUE(media_channel1_->playout());
     }
     EXPECT_TRUE(media_channel1_->sending());
   }
 
   // Test that changing the MediaContentDirection in the local and remote
   // session description start playout and sending at the right time.
   void TestMediaContentDirection() {
     CreateChannels(0, 0);
     typename T::Content content1;
     CreateContent(0, kPcmuCodec, kH264Codec, &content1);
     typename T::Content content2;
     CreateContent(0, kPcmuCodec, kH264Codec, &content2);
     // Set |content2| to be InActive.
     content2.set_direction(cricket::MD_INACTIVE);
 
     EXPECT_TRUE(channel1_->Enable(true));
     EXPECT_TRUE(channel2_->Enable(true));
     if (verify_playout_) {
       EXPECT_FALSE(media_channel1_->playout());
     }
     EXPECT_FALSE(media_channel1_->sending());
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2_->playout());
     }
     EXPECT_FALSE(media_channel2_->sending());
 
-    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, NULL));
-    EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER, NULL));
-    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER, NULL));
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, nullptr));
+    EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER, nullptr));
+    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER, nullptr));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER, nullptr));
     ConnectFakeTransports();
 
     if (verify_playout_) {
       EXPECT_TRUE(media_channel1_->playout());
     }
     EXPECT_FALSE(media_channel1_->sending());  // remote InActive
     if (verify_playout_) {
       EXPECT_FALSE(media_channel2_->playout());  // local InActive
     }
     EXPECT_FALSE(media_channel2_->sending());  // local InActive
 
     // Update |content2| to be RecvOnly.
     content2.set_direction(cricket::MD_RECVONLY);
-    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER, NULL));
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER, NULL));
+    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER, nullptr));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER, nullptr));
 
     if (verify_playout_) {
       EXPECT_TRUE(media_channel1_->playout());
     }
     EXPECT_TRUE(media_channel1_->sending());
     if (verify_playout_) {
       EXPECT_TRUE(media_channel2_->playout());  // local RecvOnly
     }
     EXPECT_FALSE(media_channel2_->sending());  // local RecvOnly
 
     // Update |content2| to be SendRecv.
     content2.set_direction(cricket::MD_SENDRECV);
-    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER, NULL));
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER, nullptr));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER, nullptr));
 
     if (verify_playout_) {
       EXPECT_TRUE(media_channel1_->playout());
     }
     EXPECT_TRUE(media_channel1_->sending());
     if (verify_playout_) {
       EXPECT_TRUE(media_channel2_->playout());
     }
     EXPECT_TRUE(media_channel2_->sending());
   }
@@ skipping 68 matching lines @@
     EXPECT_EQ(1U, media_channel2_->codecs().size());
   }
 
   // Test that we don't crash if packets are sent during call teardown
   // when RTCP mux is enabled. This is a regression test against a specific
   // race condition that would only occur when a RTCP packet was sent during
   // teardown of a channel on which RTCP mux was enabled.
   void TestCallTeardownRtcpMux() {
     class LastWordMediaChannel : public T::MediaChannel {
      public:
-      LastWordMediaChannel() : T::MediaChannel(NULL, typename T::Options()) {}
+      LastWordMediaChannel()
+          : T::MediaChannel(nullptr, typename T::Options()) {}
       ~LastWordMediaChannel() {
         T::MediaChannel::SendRtp(kPcmuFrame, sizeof(kPcmuFrame),
                                  rtc::PacketOptions());
         T::MediaChannel::SendRtcp(kRtcpReport, sizeof(kRtcpReport));
       }
     };
     CreateChannels(new LastWordMediaChannel(), new LastWordMediaChannel(),
                    RTCP_MUX, RTCP_MUX);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
@@ skipping 817 matching lines @@
     WaitForThreads();
     EXPECT_TRUE(media_channel1_->ready_to_send());
   }
 
   void TestOnReadyToSendWithRtcpMux() {
     CreateChannels(0, 0);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     // Both sides agree on mux. Should signal that RTCP mux is fully active.
     content.set_rtcp_mux(true);
-    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
+    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, nullptr));
     EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
-    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, nullptr));
     EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
     cricket::FakeDtlsTransport* rtp = fake_rtp_dtls_transport1_.get();
     EXPECT_FALSE(media_channel1_->ready_to_send());
     // In the case of rtcp mux, the SignalReadyToSend() from rtp channel
     // should trigger the MediaChannel's OnReadyToSend.
     network_thread_->Invoke<void>(RTC_FROM_HERE,
                                   [rtp] { rtp->SignalReadyToSend(rtp); });
     WaitForThreads();
     EXPECT_TRUE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
       channel1_->SetTransportChannelReadyToSend(false, false);
     });
     WaitForThreads();
     EXPECT_FALSE(media_channel1_->ready_to_send());
   }
 
   bool SetRemoteContentWithBitrateLimit(int remote_limit) {
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     content.set_bandwidth(remote_limit);
-    return channel1_->SetRemoteContent(&content, CA_OFFER, NULL);
+    return channel1_->SetRemoteContent(&content, CA_OFFER, nullptr);
   }
 
   webrtc::RtpParameters BitrateLimitedParameters(rtc::Optional<int> limit) {
     webrtc::RtpParameters parameters;
     webrtc::RtpEncodingParameters encoding;
     encoding.max_bitrate_bps = limit;
     parameters.encodings.push_back(encoding);
     return parameters;
   }
 
   void VerifyMaxBitrate(const webrtc::RtpParameters& parameters,
                         rtc::Optional<int> expected_bitrate) {
     EXPECT_EQ(1UL, parameters.encodings.size());
     EXPECT_EQ(expected_bitrate, parameters.encodings[0].max_bitrate_bps);
   }
 
   void DefaultMaxBitrateIsUnlimited() {
     CreateChannels(0, 0);
     EXPECT_TRUE(
-        channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, NULL));
+        channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, nullptr));
     EXPECT_EQ(media_channel1_->max_bps(), -1);
     VerifyMaxBitrate(media_channel1_->GetRtpSendParameters(kSsrc1),
                      rtc::Optional<int>());
   }
 
   void CanChangeMaxBitrate() {
     CreateChannels(0, 0);
     EXPECT_TRUE(
-        channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, NULL));
+        channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, nullptr));
 
     EXPECT_TRUE(channel1_->SetRtpSendParameters(
         kSsrc1, BitrateLimitedParameters(rtc::Optional<int>(1000))));
     VerifyMaxBitrate(channel1_->GetRtpSendParameters(kSsrc1),
                      rtc::Optional<int>(1000));
     VerifyMaxBitrate(media_channel1_->GetRtpSendParameters(kSsrc1),
                      rtc::Optional<int>(1000));
     EXPECT_EQ(-1, media_channel1_->max_bps());
 
     EXPECT_TRUE(channel1_->SetRtpSendParameters(
@@ skipping 105 matching lines @@
       : Base(true, kPcmuFrame, kRtcpReport, NetworkIsWorker::Yes) {}
 };
 
 class VoiceChannelDoubleThreadTest : public ChannelTest<VoiceTraits> {
  public:
   typedef ChannelTest<VoiceTraits> Base;
   VoiceChannelDoubleThreadTest()
       : Base(true, kPcmuFrame, kRtcpReport, NetworkIsWorker::No) {}
 };
 
-// override to add NULL parameter
+// override to add null parameter
 template <>
 cricket::VideoChannel* ChannelTest<VideoTraits>::CreateChannel(
     rtc::Thread* worker_thread,
     rtc::Thread* network_thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeVideoMediaChannel* ch,
     cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
     cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
     rtc::PacketTransportInternal* fake_rtp_packet_transport,
     rtc::PacketTransportInternal* fake_rtcp_packet_transport,
     int flags) {
   rtc::Thread* signaling_thread = rtc::Thread::Current();
   cricket::VideoChannel* channel = new cricket::VideoChannel(
       worker_thread, network_thread, signaling_thread, ch, cricket::CN_VIDEO,
       (flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
   rtc::CryptoOptions crypto_options;
   crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
   channel->SetCryptoOptions(crypto_options);
   if (!channel->NeedsRtcpTransport()) {
     fake_rtcp_dtls_transport = nullptr;
   }
   if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
                        fake_rtp_packet_transport, fake_rtcp_packet_transport)) {
     delete channel;
-    channel = NULL;
+    channel = nullptr;
   }
   return channel;
 }
 
 // override to add 0 parameter
 template<>
 bool ChannelTest<VideoTraits>::AddStream1(int id) {
   return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
 }
 
@@ skipping 1217 matching lines @@
       (flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
   rtc::CryptoOptions crypto_options;
   crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
   channel->SetCryptoOptions(crypto_options);
   if (!channel->NeedsRtcpTransport()) {
     fake_rtcp_dtls_transport = nullptr;
   }
   if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
                        fake_rtp_packet_transport, fake_rtcp_packet_transport)) {
     delete channel;
-    channel = NULL;
+    channel = nullptr;
   }
   return channel;
 }
 
 template <>
 void ChannelTest<DataTraits>::CreateContent(
     int flags,
     const cricket::AudioCodec& audio_codec,
     const cricket::VideoCodec& video_codec,
     cricket::DataContentDescription* data) {
@@ skipping 394 matching lines @@
   ASSERT_TRUE(voice_channel_.Init_w(nullptr, nullptr, &fake_rtp_dtls_transport_,
                                     &fake_rtcp_dtls_transport_));
   EXPECT_DEATH(voice_channel_.SetTransports(&fake_rtp_dtls_transport_,
                                             &fake_rtp_dtls_transport_),
                "");
 }
 
 #endif  // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 
 // TODO(pthatcher): TestSetReceiver?