Replace NULL with nullptr in all C++ files.

webrtc/pc/peerconnectioninterface_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 567 matching lines @@
     ice_complete_ = new_state == PeerConnectionInterface::kIceGatheringComplete;
     callback_triggered_ = true;
   }
   void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
     EXPECT_NE(PeerConnectionInterface::kIceGatheringNew,
               pc_->ice_gathering_state());
 
     std::string sdp;
     EXPECT_TRUE(candidate->ToString(&sdp));
     EXPECT_LT(0u, sdp.size());
-    last_candidate_.reset(webrtc::CreateIceCandidate(candidate->sdp_mid(),
-        candidate->sdp_mline_index(), sdp, NULL));
-    EXPECT_TRUE(last_candidate_.get() != NULL);
+    last_candidate_.reset(webrtc::CreateIceCandidate(
+        candidate->sdp_mid(), candidate->sdp_mline_index(), sdp, nullptr));
+    EXPECT_TRUE(last_candidate_.get() != nullptr);
     callback_triggered_ = true;
   }
 
   void OnIceCandidatesRemoved(
       const std::vector<cricket::Candidate>& candidates) override {
     callback_triggered_ = true;
   }
 
   void OnIceConnectionReceivingChange(bool receiving) override {
     callback_triggered_ = true;
@@ skipping 143 matching lines @@
     if (FindConstraint(constraints,
                        webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                        &dtls,
                        nullptr) && dtls) {
       fake_certificate_generator_ = new FakeRTCCertificateGenerator();
       cert_generator.reset(fake_certificate_generator_);
     }
     pc_ = pc_factory_->CreatePeerConnection(
         config, constraints, std::move(port_allocator),
         std::move(cert_generator), &observer_);
-    ASSERT_TRUE(pc_.get() != NULL);
+    ASSERT_TRUE(pc_.get() != nullptr);
     observer_.SetPeerConnectionInterface(pc_.get());
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
   }
 
   void CreatePeerConnectionExpectFail(const std::string& uri) {
     PeerConnectionInterface::RTCConfiguration config;
     PeerConnectionInterface::IceServer server;
     server.uri = uri;
     config.servers.push_back(server);
 
@@ skipping 20 matching lines @@
     EXPECT_EQ(1u, port_allocator_->turn_servers().size());
     EXPECT_EQ(kTurnUsername,
               port_allocator_->turn_servers()[0].credentials.username);
     EXPECT_EQ(kTurnPassword,
               port_allocator_->turn_servers()[0].credentials.password);
     EXPECT_EQ(kTurnHostname,
               port_allocator_->turn_servers()[0].ports[0].address.hostname());
   }
 
   void ReleasePeerConnection() {
-    pc_ = NULL;
-    observer_.SetPeerConnectionInterface(NULL);
+    pc_ = nullptr;
+    observer_.SetPeerConnectionInterface(nullptr);
   }
 
   void AddVideoStream(const std::string& label) {
     // Create a local stream.
     rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(label));
     rtc::scoped_refptr<VideoTrackSourceInterface> video_source(
-        pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer(), NULL));
+        pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer(),
+                                       nullptr));
     rtc::scoped_refptr<VideoTrackInterface> video_track(
         pc_factory_->CreateVideoTrack(label + "v0", video_source));
     stream->AddTrack(video_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
   void AddVoiceStream(const std::string& label) {
     // Create a local stream.
     rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(label));
     rtc::scoped_refptr<AudioTrackInterface> audio_track(
-        pc_factory_->CreateAudioTrack(label + "a0", NULL));
+        pc_factory_->CreateAudioTrack(label + "a0", nullptr));
     stream->AddTrack(audio_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
   void AddAudioVideoStream(const std::string& stream_label,
                            const std::string& audio_track_label,
                            const std::string& video_track_label) {
     // Create a local stream.
     rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(stream_label));
     rtc::scoped_refptr<AudioTrackInterface> audio_track(
         pc_factory_->CreateAudioTrack(
-            audio_track_label, static_cast<AudioSourceInterface*>(NULL)));
+            audio_track_label, static_cast<AudioSourceInterface*>(nullptr)));
     stream->AddTrack(audio_track.get());
     rtc::scoped_refptr<VideoTrackInterface> video_track(
         pc_factory_->CreateVideoTrack(
             video_track_label,
             pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
     stream->AddTrack(video_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
@@ skipping 65 matching lines @@
     // Create a local stream with audio&video tracks.
     AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label");
     CreateOfferReceiveAnswer();
   }
 
   // Verify that RTP Header extensions has been negotiated for audio and video.
   void VerifyRemoteRtpHeaderExtensions() {
     const cricket::MediaContentDescription* desc =
         cricket::GetFirstAudioContentDescription(
             pc_->remote_description()->description());
-    ASSERT_TRUE(desc != NULL);
+    ASSERT_TRUE(desc != nullptr);
     EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
 
     desc = cricket::GetFirstVideoContentDescription(
         pc_->remote_description()->description());
-    ASSERT_TRUE(desc != NULL);
+    ASSERT_TRUE(desc != nullptr);
     EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
   }
 
   void CreateOfferAsRemoteDescription() {
     std::unique_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
     SessionDescriptionInterface* remote_offer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
-                                         sdp, NULL);
+                                         sdp, nullptr);
     EXPECT_TRUE(DoSetRemoteDescription(remote_offer));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
 
   void CreateAndSetRemoteOffer(const std::string& sdp) {
     SessionDescriptionInterface* remote_offer =
         webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                          sdp, nullptr);
     EXPECT_TRUE(DoSetRemoteDescription(remote_offer));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
 
   void CreateAnswerAsLocalDescription() {
     std::unique_ptr<SessionDescriptionInterface> answer;
     ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
 
     // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
     // audio codec change, even if the parameter has nothing to do with
     // receiving. Not all parameters are serialized to SDP.
     // Since CreatePrAnswerAsLocalDescription serialize/deserialize
     // the SessionDescription, it is necessary to do that here to in order to
     // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass.
     // https://code.google.com/p/webrtc/issues/detail?id=1356
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
-    SessionDescriptionInterface* new_answer =
-        webrtc::CreateSessionDescription(SessionDescriptionInterface::kAnswer,
-                                         sdp, NULL);
+    SessionDescriptionInterface* new_answer = webrtc::CreateSessionDescription(
+        SessionDescriptionInterface::kAnswer, sdp, nullptr);
     EXPECT_TRUE(DoSetLocalDescription(new_answer));
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
   }
 
   void CreatePrAnswerAsLocalDescription() {
     std::unique_ptr<SessionDescriptionInterface> answer;
     ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
 
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
-    SessionDescriptionInterface* pr_answer =
-        webrtc::CreateSessionDescription(SessionDescriptionInterface::kPrAnswer,
-                                         sdp, NULL);
+    SessionDescriptionInterface* pr_answer = webrtc::CreateSessionDescription(
+        SessionDescriptionInterface::kPrAnswer, sdp, nullptr);
     EXPECT_TRUE(DoSetLocalDescription(pr_answer));
     EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_);
   }
 
   void CreateOfferReceiveAnswer() {
     CreateOfferAsLocalDescription();
     std::string sdp;
     EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
     CreateAnswerAsRemoteDescription(sdp);
   }
 
   void CreateOfferAsLocalDescription() {
     std::unique_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
     // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
     // audio codec change, even if the parameter has nothing to do with
     // receiving. Not all parameters are serialized to SDP.
     // Since CreatePrAnswerAsLocalDescription serialize/deserialize
     // the SessionDescription, it is necessary to do that here to in order to
     // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass.
     // https://code.google.com/p/webrtc/issues/detail?id=1356
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
-    SessionDescriptionInterface* new_offer =
-            webrtc::CreateSessionDescription(
-                SessionDescriptionInterface::kOffer,
-                sdp, NULL);
+    SessionDescriptionInterface* new_offer = webrtc::CreateSessionDescription(
+        SessionDescriptionInterface::kOffer, sdp, nullptr);
 
     EXPECT_TRUE(DoSetLocalDescription(new_offer));
     EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
     // Wait for the ice_complete message, so that SDP will have candidates.
     EXPECT_TRUE_WAIT(observer_.ice_complete_, kTimeout);
   }
 
   void CreateAnswerAsRemoteDescription(const std::string& sdp) {
     webrtc::JsepSessionDescription* answer = new webrtc::JsepSessionDescription(
         SessionDescriptionInterface::kAnswer);
-    EXPECT_TRUE(answer->Initialize(sdp, NULL));
+    EXPECT_TRUE(answer->Initialize(sdp, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(answer));
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
   }
 
   void CreatePrAnswerAndAnswerAsRemoteDescription(const std::string& sdp) {
     webrtc::JsepSessionDescription* pr_answer =
         new webrtc::JsepSessionDescription(
             SessionDescriptionInterface::kPrAnswer);
-    EXPECT_TRUE(pr_answer->Initialize(sdp, NULL));
+    EXPECT_TRUE(pr_answer->Initialize(sdp, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(pr_answer));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemotePrAnswer, observer_.state_);
     webrtc::JsepSessionDescription* answer =
         new webrtc::JsepSessionDescription(
             SessionDescriptionInterface::kAnswer);
-    EXPECT_TRUE(answer->Initialize(sdp, NULL));
+    EXPECT_TRUE(answer->Initialize(sdp, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(answer));
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
   }
 
   // Help function used for waiting until a the last signaled remote stream has
   // the same label as |stream_label|. In a few of the tests in this file we
   // answer with the same session description as we offer and thus we can
   // check if OnAddStream have been called with the same stream as we offer to
   // send.
   void WaitAndVerifyOnAddStream(const std::string& stream_label) {
@@ skipping 251 matching lines @@
 TEST_F(PeerConnectionInterfaceTest, AddStreams) {
   CreatePeerConnectionWithoutDtls();
   AddVideoStream(kStreamLabel1);
   AddVoiceStream(kStreamLabel2);
   ASSERT_EQ(2u, pc_->local_streams()->count());
 
   // Test we can add multiple local streams to one peerconnection.
   rtc::scoped_refptr<MediaStreamInterface> stream(
       pc_factory_->CreateLocalMediaStream(kStreamLabel3));
   rtc::scoped_refptr<AudioTrackInterface> audio_track(
-      pc_factory_->CreateAudioTrack(kStreamLabel3,
-                                    static_cast<AudioSourceInterface*>(NULL)));
+      pc_factory_->CreateAudioTrack(
+          kStreamLabel3, static_cast<AudioSourceInterface*>(nullptr)));
   stream->AddTrack(audio_track.get());
   EXPECT_TRUE(pc_->AddStream(stream));
   EXPECT_EQ(3u, pc_->local_streams()->count());
 
   // Remove the third stream.
   pc_->RemoveStream(pc_->local_streams()->at(2));
   EXPECT_EQ(2u, pc_->local_streams()->count());
 
   // Remove the second stream.
   pc_->RemoveStream(pc_->local_streams()->at(1));
@@ skipping 228 matching lines @@
   std::unique_ptr<SessionDescriptionInterface> offer;
   AddVideoStream(kStreamLabel1);
   EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
   EXPECT_TRUE(DoSetRemoteDescription(offer.release()));
 
   // SetLocalDescription takes ownership of answer.
   std::unique_ptr<SessionDescriptionInterface> answer;
   EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
   EXPECT_TRUE(DoSetLocalDescription(answer.release()));
 
-  EXPECT_TRUE_WAIT(observer_.last_candidate_.get() != NULL, kTimeout);
+  EXPECT_TRUE_WAIT(observer_.last_candidate_.get() != nullptr, kTimeout);
   EXPECT_TRUE_WAIT(observer_.ice_complete_, kTimeout);
 
   EXPECT_TRUE(pc_->AddIceCandidate(observer_.last_candidate_.get()));
 }
 
 // Test that CreateOffer and CreateAnswer will fail if the track labels are
 // not unique.
 TEST_F(PeerConnectionInterfaceTest, CreateOfferAnswerWithInvalidStream) {
   CreatePeerConnectionWithoutDtls();
   // Create a regular offer for the CreateAnswer test later.
@@ skipping 133 matching lines @@
   ASSERT_LT(0u, pc_->remote_streams()->at(0)->GetVideoTracks().size());
   rtc::scoped_refptr<MediaStreamTrackInterface> remote_video =
       pc_->remote_streams()->at(0)->GetVideoTracks()[0];
   EXPECT_TRUE(DoGetStats(remote_video));
 }
 
 // Test that we don't get statistics for an invalid track.
 TEST_F(PeerConnectionInterfaceTest, GetStatsForInvalidTrack) {
   InitiateCall();
   rtc::scoped_refptr<AudioTrackInterface> unknown_audio_track(
-      pc_factory_->CreateAudioTrack("unknown track", NULL));
+      pc_factory_->CreateAudioTrack("unknown track", nullptr));
   EXPECT_FALSE(DoGetStats(unknown_audio_track));
 }
 
 // This test setup two RTP data channels in loop back.
 TEST_F(PeerConnectionInterfaceTest, TestDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
   rtc::scoped_refptr<DataChannelInterface> data1 =
-      pc_->CreateDataChannel("test1", NULL);
+      pc_->CreateDataChannel("test1", nullptr);
   rtc::scoped_refptr<DataChannelInterface> data2 =
-      pc_->CreateDataChannel("test2", NULL);
-  ASSERT_TRUE(data1 != NULL);
+      pc_->CreateDataChannel("test2", nullptr);
+  ASSERT_TRUE(data1 != nullptr);
   std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
   std::unique_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   EXPECT_EQ(DataChannelInterface::kConnecting, data1->state());
   EXPECT_EQ(DataChannelInterface::kConnecting, data2->state());
   std::string data_to_send1 = "testing testing";
   std::string data_to_send2 = "testing something else";
   EXPECT_FALSE(data1->Send(DataBuffer(data_to_send1)));
@@ skipping 23 matching lines @@
   EXPECT_EQ_WAIT(data_to_send2, observer2->last_message(), kTimeout);
 }
 
 // This test verifies that sendnig binary data over RTP data channels should
 // fail.
 TEST_F(PeerConnectionInterfaceTest, TestSendBinaryOnRtpDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
   rtc::scoped_refptr<DataChannelInterface> data1 =
-      pc_->CreateDataChannel("test1", NULL);
+      pc_->CreateDataChannel("test1", nullptr);
   rtc::scoped_refptr<DataChannelInterface> data2 =
-      pc_->CreateDataChannel("test2", NULL);
-  ASSERT_TRUE(data1 != NULL);
+      pc_->CreateDataChannel("test2", nullptr);
+  ASSERT_TRUE(data1 != nullptr);
   std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
   std::unique_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   EXPECT_EQ(DataChannelInterface::kConnecting, data1->state());
   EXPECT_EQ(DataChannelInterface::kConnecting, data2->state());
 
   CreateOfferReceiveAnswer();
   EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout);
   EXPECT_TRUE_WAIT(observer2->IsOpen(), kTimeout);
 
   EXPECT_EQ(DataChannelInterface::kOpen, data1->state());
   EXPECT_EQ(DataChannelInterface::kOpen, data2->state());
 
   rtc::CopyOnWriteBuffer buffer("test", 4);
   EXPECT_FALSE(data1->Send(DataBuffer(buffer, true)));
 }
 
 // This test setup a RTP data channels in loop back and test that a channel is
 // opened even if the remote end answer with a zero SSRC.
 TEST_F(PeerConnectionInterfaceTest, TestSendOnlyDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
   rtc::scoped_refptr<DataChannelInterface> data1 =
-      pc_->CreateDataChannel("test1", NULL);
+      pc_->CreateDataChannel("test1", nullptr);
   std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
 
   CreateOfferReceiveAnswerWithoutSsrc();
 
   EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout);
 
   data1->Close();
   EXPECT_EQ(DataChannelInterface::kClosing, data1->state());
   CreateOfferReceiveAnswerWithoutSsrc();
   EXPECT_EQ(DataChannelInterface::kClosed, data1->state());
   EXPECT_FALSE(observer1->IsOpen());
 }
 
 // This test that if a data channel is added in an answer a receive only channel
 // channel is created.
 TEST_F(PeerConnectionInterfaceTest, TestReceiveOnlyDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   std::string offer_label = "offer_channel";
   rtc::scoped_refptr<DataChannelInterface> offer_channel =
-      pc_->CreateDataChannel(offer_label, NULL);
+      pc_->CreateDataChannel(offer_label, nullptr);
 
   CreateOfferAsLocalDescription();
 
   // Replace the data channel label in the offer and apply it as an answer.
   std::string receive_label = "answer_channel";
   std::string sdp;
   EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
   rtc::replace_substrs(offer_label.c_str(), offer_label.length(),
                              receive_label.c_str(), receive_label.length(),
                              &sdp);
   CreateAnswerAsRemoteDescription(sdp);
 
   // Verify that a new incoming data channel has been created and that
   // it is open but can't we written to.
-  ASSERT_TRUE(observer_.last_datachannel_ != NULL);
+  ASSERT_TRUE(observer_.last_datachannel_ != nullptr);
   DataChannelInterface* received_channel = observer_.last_datachannel_;
   EXPECT_EQ(DataChannelInterface::kConnecting, received_channel->state());
   EXPECT_EQ(receive_label, received_channel->label());
   EXPECT_FALSE(received_channel->Send(DataBuffer("something")));
 
   // Verify that the channel we initially offered has been rejected.
   EXPECT_EQ(DataChannelInterface::kClosed, offer_channel->state());
 
   // Do another offer / answer exchange and verify that the data channel is
   // opened.
   CreateOfferReceiveAnswer();
   EXPECT_EQ_WAIT(DataChannelInterface::kOpen, received_channel->state(),
                  kTimeout);
 }
 
 // This test that no data channel is returned if a reliable channel is
 // requested.
 // TODO(perkj): Remove this test once reliable channels are implemented.
 TEST_F(PeerConnectionInterfaceTest, CreateReliableRtpDataChannelShouldFail) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   std::string label = "test";
   webrtc::DataChannelInit config;
   config.reliable = true;
   rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel(label, &config);
-  EXPECT_TRUE(channel == NULL);
+  EXPECT_TRUE(channel == nullptr);
 }
 
 // Verifies that duplicated label is not allowed for RTP data channel.
 TEST_F(PeerConnectionInterfaceTest, RtpDuplicatedLabelNotAllowed) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   std::string label = "test";
   rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel(label, nullptr);
   EXPECT_NE(channel, nullptr);
 
   rtc::scoped_refptr<DataChannelInterface> dup_channel =
       pc_->CreateDataChannel(label, nullptr);
   EXPECT_EQ(dup_channel, nullptr);
 }
 
 // This tests that a SCTP data channel is returned using different
 // DataChannelInit configurations.
 TEST_F(PeerConnectionInterfaceTest, CreateSctpDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowDtlsSctpDataChannels();
   CreatePeerConnection(&constraints);
 
   webrtc::DataChannelInit config;
 
   rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel("1", &config);
-  EXPECT_TRUE(channel != NULL);
+  EXPECT_TRUE(channel != nullptr);
   EXPECT_TRUE(channel->reliable());
   EXPECT_TRUE(observer_.renegotiation_needed_);
   observer_.renegotiation_needed_ = false;
 
   config.ordered = false;
   channel = pc_->CreateDataChannel("2", &config);
-  EXPECT_TRUE(channel != NULL);
+  EXPECT_TRUE(channel != nullptr);
   EXPECT_TRUE(channel->reliable());
   EXPECT_FALSE(observer_.renegotiation_needed_);
 
   config.ordered = true;
   config.maxRetransmits = 0;
   channel = pc_->CreateDataChannel("3", &config);
-  EXPECT_TRUE(channel != NULL);
+  EXPECT_TRUE(channel != nullptr);
   EXPECT_FALSE(channel->reliable());
   EXPECT_FALSE(observer_.renegotiation_needed_);
 
   config.maxRetransmits = -1;
   config.maxRetransmitTime = 0;
   channel = pc_->CreateDataChannel("4", &config);
-  EXPECT_TRUE(channel != NULL);
+  EXPECT_TRUE(channel != nullptr);
   EXPECT_FALSE(channel->reliable());
   EXPECT_FALSE(observer_.renegotiation_needed_);
 }
 
 // This tests that no data channel is returned if both maxRetransmits and
 // maxRetransmitTime are set for SCTP data channels.
 TEST_F(PeerConnectionInterfaceTest,
        CreateSctpDataChannelShouldFailForInvalidConfig) {
   FakeConstraints constraints;
   constraints.SetAllowDtlsSctpDataChannels();
   CreatePeerConnection(&constraints);
 
   std::string label = "test";
   webrtc::DataChannelInit config;
   config.maxRetransmits = 0;
   config.maxRetransmitTime = 0;
 
   rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel(label, &config);
-  EXPECT_TRUE(channel == NULL);
+  EXPECT_TRUE(channel == nullptr);
 }
 
 // The test verifies that creating a SCTP data channel with an id already in use
 // or out of range should fail.
 TEST_F(PeerConnectionInterfaceTest,
        CreateSctpDataChannelWithInvalidIdShouldFail) {
   FakeConstraints constraints;
   constraints.SetAllowDtlsSctpDataChannels();
   CreatePeerConnection(&constraints);
 
   webrtc::DataChannelInit config;
   rtc::scoped_refptr<DataChannelInterface> channel;
 
   config.id = 1;
   channel = pc_->CreateDataChannel("1", &config);
-  EXPECT_TRUE(channel != NULL);
+  EXPECT_TRUE(channel != nullptr);
   EXPECT_EQ(1, channel->id());
 
   channel = pc_->CreateDataChannel("x", &config);
-  EXPECT_TRUE(channel == NULL);
+  EXPECT_TRUE(channel == nullptr);
 
   config.id = cricket::kMaxSctpSid;
   channel = pc_->CreateDataChannel("max", &config);
-  EXPECT_TRUE(channel != NULL);
+  EXPECT_TRUE(channel != nullptr);
   EXPECT_EQ(config.id, channel->id());
 
   config.id = cricket::kMaxSctpSid + 1;
   channel = pc_->CreateDataChannel("x", &config);
-  EXPECT_TRUE(channel == NULL);
+  EXPECT_TRUE(channel == nullptr);
 }
 
 // Verifies that duplicated label is allowed for SCTP data channel.
 TEST_F(PeerConnectionInterfaceTest, SctpDuplicatedLabelAllowed) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
 
   std::string label = "test";
   rtc::scoped_refptr<DataChannelInterface> channel =
       pc_->CreateDataChannel(label, nullptr);
   EXPECT_NE(channel, nullptr);
 
   rtc::scoped_refptr<DataChannelInterface> dup_channel =
       pc_->CreateDataChannel(label, nullptr);
   EXPECT_NE(dup_channel, nullptr);
 }
 
 // This test verifies that OnRenegotiationNeeded is fired for every new RTP
 // DataChannel.
 TEST_F(PeerConnectionInterfaceTest, RenegotiationNeededForNewRtpDataChannel) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   rtc::scoped_refptr<DataChannelInterface> dc1 =
-      pc_->CreateDataChannel("test1", NULL);
+      pc_->CreateDataChannel("test1", nullptr);
   EXPECT_TRUE(observer_.renegotiation_needed_);
   observer_.renegotiation_needed_ = false;
 
   rtc::scoped_refptr<DataChannelInterface> dc2 =
-      pc_->CreateDataChannel("test2", NULL);
+      pc_->CreateDataChannel("test2", nullptr);
   EXPECT_TRUE(observer_.renegotiation_needed_);
 }
 
 // This test that a data channel closes when a PeerConnection is deleted/closed.
 TEST_F(PeerConnectionInterfaceTest, DataChannelCloseWhenPeerConnectionClose) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   rtc::scoped_refptr<DataChannelInterface> data1 =
-      pc_->CreateDataChannel("test1", NULL);
+      pc_->CreateDataChannel("test1", nullptr);
   rtc::scoped_refptr<DataChannelInterface> data2 =
-      pc_->CreateDataChannel("test2", NULL);
-  ASSERT_TRUE(data1 != NULL);
+      pc_->CreateDataChannel("test2", nullptr);
+  ASSERT_TRUE(data1 != nullptr);
   std::unique_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
   std::unique_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   CreateOfferReceiveAnswer();
   EXPECT_TRUE_WAIT(observer1->IsOpen(), kTimeout);
   EXPECT_TRUE_WAIT(observer2->IsOpen(), kTimeout);
 
   ReleasePeerConnection();
   EXPECT_EQ(DataChannelInterface::kClosed, data1->state());
   EXPECT_EQ(DataChannelInterface::kClosed, data2->state());
 }
 
 // This test that data channels can be rejected in an answer.
 TEST_F(PeerConnectionInterfaceTest, TestRejectDataChannelInAnswer) {
   FakeConstraints constraints;
   constraints.SetAllowRtpDataChannels();
   CreatePeerConnection(&constraints);
 
   rtc::scoped_refptr<DataChannelInterface> offer_channel(
-      pc_->CreateDataChannel("offer_channel", NULL));
+      pc_->CreateDataChannel("offer_channel", nullptr));
 
   CreateOfferAsLocalDescription();
 
   // Create an answer where the m-line for data channels are rejected.
   std::string sdp;
   EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
   webrtc::JsepSessionDescription* answer = new webrtc::JsepSessionDescription(
       SessionDescriptionInterface::kAnswer);
-  EXPECT_TRUE(answer->Initialize(sdp, NULL));
+  EXPECT_TRUE(answer->Initialize(sdp, nullptr));
   cricket::ContentInfo* data_info =
       answer->description()->GetContentByName("data");
   data_info->rejected = true;
 
   DoSetRemoteDescription(answer);
   EXPECT_EQ(DataChannelInterface::kClosed, offer_channel->state());
 }
 
 // Test that we can create a session description from an SDP string from
 // FireFox, use it as a remote session description, generate an answer and use
 // the answer as a local description.
 TEST_F(PeerConnectionInterfaceTest, ReceiveFireFoxOffer) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   AddAudioVideoStream(kStreamLabel1, "audio_label", "video_label");
   SessionDescriptionInterface* desc =
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        webrtc::kFireFoxSdpOffer, nullptr);
   EXPECT_TRUE(DoSetSessionDescription(desc, false));
   CreateAnswerAsLocalDescription();
-  ASSERT_TRUE(pc_->local_description() != NULL);
-  ASSERT_TRUE(pc_->remote_description() != NULL);
+  ASSERT_TRUE(pc_->local_description() != nullptr);
+  ASSERT_TRUE(pc_->remote_description() != nullptr);
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(pc_->local_description()->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_FALSE(content->rejected);
 
   content =
       cricket::GetFirstVideoContent(pc_->local_description()->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_FALSE(content->rejected);
 #ifdef HAVE_SCTP
   content =
       cricket::GetFirstDataContent(pc_->local_description()->description());
-  ASSERT_TRUE(content != NULL);
+  ASSERT_TRUE(content != nullptr);
   EXPECT_TRUE(content->rejected);
 #endif
 }
 
 // Test that an offer can be received which offers DTLS with SDES fallback.
 // Regression test for issue:
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=6972
 TEST_F(PeerConnectionInterfaceTest, ReceiveDtlsSdesFallbackOffer) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
@@ skipping 315 matching lines @@
       pc_->local_streams()->at(0);
 
   pc_->Close();
 
   pc_->RemoveStream(local_stream);
   EXPECT_FALSE(pc_->AddStream(local_stream));
 
   ASSERT_FALSE(local_stream->GetAudioTracks().empty());
   rtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf_sender(
       pc_->CreateDtmfSender(local_stream->GetAudioTracks()[0]));
-  EXPECT_TRUE(NULL == dtmf_sender);  // local stream has been removed.
+  EXPECT_TRUE(nullptr == dtmf_sender);  // local stream has been removed.
 
-  EXPECT_TRUE(pc_->CreateDataChannel("test", NULL) == NULL);
+  EXPECT_TRUE(pc_->CreateDataChannel("test", nullptr) == nullptr);
 
-  EXPECT_TRUE(pc_->local_description() != NULL);
-  EXPECT_TRUE(pc_->remote_description() != NULL);
+  EXPECT_TRUE(pc_->local_description() != nullptr);
+  EXPECT_TRUE(pc_->remote_description() != nullptr);
 
   std::unique_ptr<SessionDescriptionInterface> offer;
   EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
   std::unique_ptr<SessionDescriptionInterface> answer;
   EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
 
   std::string sdp;
   ASSERT_TRUE(pc_->remote_description()->ToString(&sdp));
-  SessionDescriptionInterface* remote_offer =
-      webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
-                                       sdp, NULL);
+  SessionDescriptionInterface* remote_offer = webrtc::CreateSessionDescription(
+      SessionDescriptionInterface::kOffer, sdp, nullptr);
   EXPECT_FALSE(DoSetRemoteDescription(remote_offer));
 
   ASSERT_TRUE(pc_->local_description()->ToString(&sdp));
-  SessionDescriptionInterface* local_offer =
-        webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
-                                         sdp, NULL);
+  SessionDescriptionInterface* local_offer = webrtc::CreateSessionDescription(
+      SessionDescriptionInterface::kOffer, sdp, nullptr);
   EXPECT_FALSE(DoSetLocalDescription(local_offer));
 }
 
 // Test that GetStats can still be called after PeerConnection::Close.
 TEST_F(PeerConnectionInterfaceTest, CloseAndGetStats) {
   InitiateCall();
   pc_->Close();
-  DoGetStats(NULL);
+  DoGetStats(nullptr);
 }
 
 // NOTE: The series of tests below come from what used to be
 // mediastreamsignaling_unittest.cc, and are mostly aimed at testing that
 // setting a remote or local description has the expected effects.
 
 // This test verifies that the remote MediaStreams corresponding to a received
 // SDP string is created. In this test the two separate MediaStreams are
 // signaled.
 TEST_F(PeerConnectionInterfaceTest, UpdateRemoteStreams) {
@@ skipping 379 matching lines @@
   EXPECT_TRUE(DoSetLocalDescription(offer.release()));
 
   auto senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
 
   // Change the ssrc of the audio and video track.
   cricket::MediaContentDescription* desc =
       cricket::GetFirstAudioContentDescription(modified_offer->description());
-  ASSERT_TRUE(desc != NULL);
+  ASSERT_TRUE(desc != nullptr);
   for (StreamParams& stream : desc->mutable_streams()) {
     for (unsigned int& ssrc : stream.ssrcs) {
       ++ssrc;
     }
   }
 
   desc =
       cricket::GetFirstVideoContentDescription(modified_offer->description());
-  ASSERT_TRUE(desc != NULL);
+  ASSERT_TRUE(desc != nullptr);
   for (StreamParams& stream : desc->mutable_streams()) {
     for (unsigned int& ssrc : stream.ssrcs) {
       ++ssrc;
     }
   }
 
   EXPECT_TRUE(DoSetLocalDescription(modified_offer.release()));
   senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
@@ skipping 547 matching lines @@
   EXPECT_NE(a, f);
 
   PeerConnectionInterface::RTCConfiguration g;
   g.disable_ipv6 = true;
   EXPECT_NE(a, g);
 
   PeerConnectionInterface::RTCConfiguration h(
       PeerConnectionInterface::RTCConfigurationType::kAggressive);
   EXPECT_NE(a, h);
 }