Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/dtlstransportchannel.cc

 /*
  *  Copyright 2011 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 77 matching lines @@
   ice_transport_->SendPacket(static_cast<const char*>(data), data_len,
                              packet_options);
   if (written) {
     *written = data_len;
   }
   return rtc::SR_SUCCESS;
 }
 
 bool StreamInterfaceChannel::OnPacketReceived(const char* data, size_t size) {
   // We force a read event here to ensure that we don't overflow our queue.
-  bool ret = packets_.WriteBack(data, size, NULL);
+  bool ret = packets_.WriteBack(data, size, nullptr);
   RTC_CHECK(ret) << "Failed to write packet to queue.";
   if (ret) {
     SignalEvent(this, rtc::SE_READ, 0);
   }
   return ret;
 }
 
 void StreamInterfaceChannel::Close() {
   packets_.Clear();
   state_ = rtc::SS_CLOSED;
 }
 
 DtlsTransport::DtlsTransport(IceTransportInternal* ice_transport)
     : transport_name_(ice_transport->transport_name()),
       component_(ice_transport->component()),
       network_thread_(rtc::Thread::Current()),
       ice_transport_(ice_transport),
-      downward_(NULL),
+      downward_(nullptr),
       ssl_role_(rtc::SSL_CLIENT),
       ssl_max_version_(rtc::SSL_PROTOCOL_DTLS_12) {
   ice_transport_->SignalWritableState.connect(this,
                                               &DtlsTransport::OnWritableState);
   ice_transport_->SignalReadPacket.connect(this, &DtlsTransport::OnReadPacket);
   ice_transport_->SignalSentPacket.connect(this, &DtlsTransport::OnSentPacket);
   ice_transport_->SignalReadyToSend.connect(this,
                                             &DtlsTransport::OnReadyToSend);
   ice_transport_->SignalReceivingState.connect(
       this, &DtlsTransport::OnReceivingState);
@@ skipping 11 matching lines @@
     } else {
       LOG_J(LS_ERROR, this) << "Can't change DTLS local identity in this state";
       return false;
     }
   }
 
   if (certificate) {
     local_certificate_ = certificate;
     dtls_active_ = true;
   } else {
-    LOG_J(LS_INFO, this) << "NULL DTLS identity supplied. Not doing DTLS";
+    LOG_J(LS_INFO, this) << "null DTLS identity supplied. Not doing DTLS";
   }
 
   return true;
 }
 
 rtc::scoped_refptr<rtc::RTCCertificate> DtlsTransport::GetLocalCertificate()
     const {
   return local_certificate_;
 }
 
@@ skipping 219 matching lines @@
                               const rtc::PacketOptions& options,
                               int flags) {
   if (!dtls_active_) {
     // Not doing DTLS.
     return ice_transport_->SendPacket(data, size, options);
   }
 
   switch (dtls_state()) {
     case DTLS_TRANSPORT_NEW:
       // Can't send data until the connection is active.
-      // TODO(ekr@rtfm.com): assert here if dtls_ is NULL?
+      // TODO(ekr@rtfm.com): assert here if dtls_ is null?
       return -1;
     case DTLS_TRANSPORT_CONNECTING:
       // Can't send data until the connection is active.
       return -1;
     case DTLS_TRANSPORT_CONNECTED:
       if (flags & PF_SRTP_BYPASS) {
         RTC_DCHECK(!srtp_ciphers_.empty());
         if (!IsRtpPacket(data, size)) {
           return -1;
         }
 
         return ice_transport_->SendPacket(data, size, options);
       } else {
-        return (dtls_->WriteAll(data, size, NULL, NULL) == rtc::SR_SUCCESS)
+        return (dtls_->WriteAll(data, size, nullptr, nullptr) ==
+                rtc::SR_SUCCESS)
                    ? static_cast<int>(size)
                    : -1;
       }
     case DTLS_TRANSPORT_FAILED:
     case DTLS_TRANSPORT_CLOSED:
       // Can't send anything when we're closed.
       return -1;
     default:
       RTC_NOTREACHED();
       return -1;
@@ skipping 302 matching lines @@
 
     dtls_->SetInitialRetransmissionTimeout(initial_timeout);
   } else {
     LOG_J(LS_INFO, this)
         << "no RTT estimate - using default DTLS handshake timeout";
   }
 }
 
 
 }  // namespace cricket