Replace NULL with nullptr in all C++ files.

webrtc/voice_engine/test/channel_transport/udp_transport_impl.cc

 /*
  *  Copyright (c) 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 106 matching lines @@
       _localPort(0),
       _localPortRTCP(0),
       _srcPort(0),
       _srcPortRTCP(0),
       _fromPort(0),
       _fromPortRTCP(0),
       _fromIP(),
       _destIP(),
       _localIP(),
       _localMulticastIP(),
-      _ptrRtpSocket(NULL),
-      _ptrRtcpSocket(NULL),
-      _ptrSendRtpSocket(NULL),
-      _ptrSendRtcpSocket(NULL),
+      _ptrRtpSocket(nullptr),
+      _ptrRtcpSocket(nullptr),
+      _ptrSendRtpSocket(nullptr),
+      _ptrSendRtcpSocket(nullptr),
       _remoteRTPAddr(),
       _remoteRTCPAddr(),
       _localRTPAddr(),
       _localRTCPAddr(),
       _tos(0),
       _receiving(false),
       _useSetSockOpt(false),
       _qos(false),
       _pcp(0),
       _ipV6Enabled(false),
       _serviceType(0),
       _overrideDSCP(0),
       _maxBitrate(0),
       _cachLock(RWLockWrapper::CreateRWLock()),
       _previousAddress(),
       _previousIP(),
       _previousIPSize(0),
       _previousSourcePort(0),
       _filterIPAddress(),
       _rtpFilterPort(0),
       _rtcpFilterPort(0),
-      _packetCallback(0)
-{
-    memset(&_remoteRTPAddr, 0, sizeof(_remoteRTPAddr));
-    memset(&_remoteRTCPAddr, 0, sizeof(_remoteRTCPAddr));
-    memset(&_localRTPAddr, 0, sizeof(_localRTPAddr));
-    memset(&_localRTCPAddr, 0, sizeof(_localRTCPAddr));
+      _packetCallback(0) {
+  memset(&_remoteRTPAddr, 0, sizeof(_remoteRTPAddr));
+  memset(&_remoteRTCPAddr, 0, sizeof(_remoteRTCPAddr));
+  memset(&_localRTPAddr, 0, sizeof(_localRTPAddr));
+  memset(&_localRTCPAddr, 0, sizeof(_localRTCPAddr));
 
-    memset(_fromIP, 0, sizeof(_fromIP));
-    memset(_destIP, 0, sizeof(_destIP));
-    memset(_localIP, 0, sizeof(_localIP));
-    memset(_localMulticastIP, 0, sizeof(_localMulticastIP));
+  memset(_fromIP, 0, sizeof(_fromIP));
+  memset(_destIP, 0, sizeof(_destIP));
+  memset(_localIP, 0, sizeof(_localIP));
+  memset(_localMulticastIP, 0, sizeof(_localMulticastIP));
 
-    memset(&_filterIPAddress, 0, sizeof(_filterIPAddress));
+  memset(&_filterIPAddress, 0, sizeof(_filterIPAddress));
 
-    WEBRTC_TRACE(kTraceMemory, kTraceTransport, id, "%s created", __FUNCTION__);
+  WEBRTC_TRACE(kTraceMemory, kTraceTransport, id, "%s created", __FUNCTION__);
 }
 
 UdpTransportImpl::~UdpTransportImpl()
 {
     CloseSendSockets();
     CloseReceiveSockets();
     delete _crit;
     delete _critFilter;
     delete _critPacketCallback;
     delete _cachLock;
@@ skipping 58 matching lines @@
     UdpTransportData* const packetCallback,
     const uint16_t portnr,
     const char* ip,
     const char* multicastIpAddr,
     const uint16_t rtcpPort)
 {
     {
         CriticalSectionScoped cs(_critPacketCallback);
         _packetCallback = packetCallback;
 
-        if(packetCallback == NULL)
-        {
-            WEBRTC_TRACE(kTraceStateInfo, kTraceTransport, _id,
-                         "Closing down receive sockets");
-            return 0;
+        if (packetCallback == nullptr) {
+          WEBRTC_TRACE(kTraceStateInfo, kTraceTransport, _id,
+                       "Closing down receive sockets");
+          return 0;
         }
     }
 
     CriticalSectionScoped cs(_crit);
     CloseReceiveSockets();
 
     if(portnr == 0)
     {
         // TODO (hellner): why not just fail here?
         if(_destPort == 0)
@@ skipping 52 matching lines @@
             strncpy(_localMulticastIP, multicastIpAddr,
                     kIpAddressVersion6Length);
         } else
         {
             WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
                          "InitializeReceiveSockets invalid IP address");
             _lastError =  kIpAddressInvalid;
             return -1;
         }
     }
-    if(_mgr == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
-                     "InitializeReceiveSockets no socket manager");
-        return -1;
+    if (_mgr == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                   "InitializeReceiveSockets no socket manager");
+      return -1;
     }
 
     _useSetSockOpt=false;
     _tos=0;
     _pcp=0;
 
     _ptrRtpSocket = _socket_creator->CreateSocket(_id, _mgr, this,
                                     IncomingRTPCallback,
                                     IpV6Enabled(), false);
 
@@ skipping 408 matching lines @@
             WEBRTC_TRACE(
                 kTraceError,
                 kTraceTransport,
                 _id,
                 "Can't switch SetSockOpt method without disabling TOS first");
             _lastError = kTosInvalid;
             return -1;
         }
     }
     CriticalSectionScoped cs(_crit);
-    UdpSocketWrapper* rtpSock = NULL;
-    UdpSocketWrapper* rtcpSock = NULL;
+    UdpSocketWrapper* rtpSock = nullptr;
+    UdpSocketWrapper* rtcpSock = nullptr;
     if(_ptrSendRtpSocket)
     {
         rtpSock = _ptrSendRtpSocket;
     }else
     {
         rtpSock = _ptrRtpSocket;
     }
-    if (rtpSock == NULL)
-    {
-        _lastError = kSocketInvalid;
-        return -1;
+    if (rtpSock == nullptr) {
+      _lastError = kSocketInvalid;
+      return -1;
     }
     if(!rtpSock->ValidHandle())
     {
         _lastError = kSocketInvalid;
         return -1;
     }
     if(_ptrSendRtcpSocket)
     {
         rtcpSock = _ptrSendRtcpSocket;
     }else
     {
         rtcpSock = _ptrRtcpSocket;
     }
-    if (rtcpSock == NULL)
-    {
-        _lastError = kSocketInvalid;
-        return -1;
+    if (rtcpSock == nullptr) {
+      _lastError = kSocketInvalid;
+      return -1;
     }
     if(!rtcpSock->ValidHandle())
     {
         _lastError = kSocketInvalid;
         return -1;
     }
 
     if (useSetSockOpt)
     {
 #ifdef _WIN32
         OSVERSIONINFO OsVersion;
         OsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
         GetVersionEx(&OsVersion);
         // Disable QoS before setting ToS on Windows XP. This is done by closing
         // and re-opening the sockets.
         // TODO (hellner): why not just fail here and force the user to
         //                 re-initialize sockets? Doing this may trick the user
         //                 into thinking that the sockets are in a state which
         //                 they aren't.
         if (OsVersion.dwMajorVersion == 5 &&
             OsVersion.dwMinorVersion == 1)
         {
             if(!_useSetSockOpt)
             {
                 if(_ptrSendRtpSocket)
                 {
                     CloseSendSockets();
-                    _ptrSendRtpSocket =
-                        _socket_creator->CreateSocket(_id, _mgr, NULL,
-                                        NULL, IpV6Enabled(),
-                                        true);
-                    _ptrSendRtcpSocket =
-                        _socket_creator->CreateSocket(_id, _mgr, NULL,
-                                        NULL, IpV6Enabled(),
-                                        true);
+                    _ptrSendRtpSocket = _socket_creator->CreateSocket(
+                        _id, _mgr, nullptr, nullptr, IpV6Enabled(), true);
+                    _ptrSendRtcpSocket = _socket_creator->CreateSocket(
+                        _id, _mgr, nullptr, nullptr, IpV6Enabled(), true);
                     rtpSock=_ptrSendRtpSocket;
                     rtcpSock=_ptrSendRtcpSocket;
                     ErrorCode retVal = BindRTPSendSocket();
                     if(retVal != kNoSocketError)
                     {
                         _lastError = retVal;
                         return -1;
                     }
                     retVal = BindRTCPSendSocket();
                     if(retVal != kNoSocketError)
@@ skipping 109 matching lines @@
         return -1;
     }
     if ((PCP < 0) || (PCP > 7))
     {
         WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "Invalid PCP");
         _lastError = kPcpError;
         return -1;
     }
 
     CriticalSectionScoped cs(_crit);
-    UdpSocketWrapper* rtpSock = NULL;
-    UdpSocketWrapper* rtcpSock = NULL;
+    UdpSocketWrapper* rtpSock = nullptr;
+    UdpSocketWrapper* rtcpSock = nullptr;
     if(_ptrSendRtpSocket)
     {
         rtpSock = _ptrSendRtpSocket;
     }else
     {
         rtpSock = _ptrRtpSocket;
     }
-    if (rtpSock == NULL)
-    {
-        _lastError = kSocketInvalid;
-        return -1;
+    if (rtpSock == nullptr) {
+      _lastError = kSocketInvalid;
+      return -1;
     }
     if(!rtpSock->ValidHandle())
     {
         _lastError = kSocketInvalid;
         return -1;
     }
     if(_ptrSendRtcpSocket)
     {
         rtcpSock = _ptrSendRtcpSocket;
     }else
     {
         rtcpSock = _ptrRtcpSocket;
     }
-    if (rtcpSock == NULL)
-    {
-        _lastError = kSocketInvalid;
-        return -1;
+    if (rtcpSock == nullptr) {
+      _lastError = kSocketInvalid;
+      return -1;
     }
     if(!rtcpSock->ValidHandle())
     {
         _lastError = kSocketInvalid;
         return -1;
     }
 
 #if defined(_WIN32)
     if (rtpSock->SetPCP(PCP) != 0)
     {
@@ skipping 60 matching lines @@
     _lastError = kIpVersion6Error;
     return -1;
   }
   _ipV6Enabled = true;
   return 0;
 }
 
 int32_t UdpTransportImpl::FilterIP(
     char filterIPAddress[kIpAddressVersion6Length]) const
 {
-
-    if(filterIPAddress == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
-                     "FilterIP: Invalid argument");
-        return -1;
+  if (filterIPAddress == nullptr) {
+    WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                 "FilterIP: Invalid argument");
+    return -1;
     }
     if(_filterIPAddress._sockaddr_storage.sin_family == 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceTransport, _id, "No Filter configured");
         return -1;
     }
     CriticalSectionScoped cs(_critFilter);
     uint32_t ipSize = kIpAddressVersion6Length;
     uint16_t sourcePort;
     return IPAddress(_filterIPAddress, filterIPAddress, ipSize, sourcePort);
 }
 
 int32_t UdpTransportImpl::SetFilterIP(
     const char filterIPAddress[kIpAddressVersion6Length])
 {
-    if(filterIPAddress == NULL)
-    {
-        memset(&_filterIPAddress, 0, sizeof(_filterIPAddress));
-        WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id, "Filter IP reset");
-        return 0;
+  if (filterIPAddress == nullptr) {
+    memset(&_filterIPAddress, 0, sizeof(_filterIPAddress));
+    WEBRTC_TRACE(kTraceDebug, kTraceTransport, _id, "Filter IP reset");
+    return 0;
     }
     CriticalSectionScoped cs(_critFilter);
     if (_ipV6Enabled)
     {
         _filterIPAddress._sockaddr_storage.sin_family = AF_INET6;
 
         if (InetPresentationToNumeric(
                 AF_INET6,
                 filterIPAddress,
                 &_filterIPAddress._sockaddr_in6.sin6_addr) < 0)
@@ skipping 390 matching lines @@
         WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
                      "InitializeSourcePorts port 0 not allowed");
         _lastError = kPortInvalid;
         return -1;
     }
 
     CriticalSectionScoped cs(_crit);
 
     CloseSendSockets();
 
-    if(_mgr == NULL)
-    {
-        return -1;
+    if (_mgr == nullptr) {
+      return -1;
     }
 
     _srcPort = rtpPort;
     if(rtcpPort == 0)
     {
         _srcPortRTCP = rtpPort+1;
     } else
     {
         _srcPortRTCP = rtcpPort;
     }
     _useSetSockOpt =false;
     _tos=0;
     _pcp=0;
 
-    _ptrSendRtpSocket = _socket_creator->CreateSocket(_id, _mgr, NULL, NULL,
-                                        IpV6Enabled(), false);
-    _ptrSendRtcpSocket = _socket_creator->CreateSocket(_id, _mgr, NULL, NULL,
-                                         IpV6Enabled(), false);
+    _ptrSendRtpSocket = _socket_creator->CreateSocket(
+        _id, _mgr, nullptr, nullptr, IpV6Enabled(), false);
+    _ptrSendRtcpSocket = _socket_creator->CreateSocket(
+        _id, _mgr, nullptr, nullptr, IpV6Enabled(), false);
 
     ErrorCode retVal = BindRTPSendSocket();
     if(retVal != kNoSocketError)
     {
         _lastError = retVal;
         return -1;
     }
     retVal = BindRTCPSendSocket();
     if(retVal != kNoSocketError)
     {
@@ skipping 42 matching lines @@
     if(_ptrRtcpSocket)
     {
         if(!_ptrRtcpSocket->StartReceiving())
         {
             WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
                          "Failed to start receive on RTCP socket");
             _lastError = kStartReceiveError;
             return -1;
         }
     }
-    if( _ptrRtpSocket == NULL &&
-        _ptrRtcpSocket == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
-                     "Failed to StartReceiving, no socket initialized");
-        _lastError = kStartReceiveError;
-        return -1;
+    if (_ptrRtpSocket == nullptr && _ptrRtcpSocket == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                   "Failed to StartReceiving, no socket initialized");
+      _lastError = kStartReceiveError;
+      return -1;
     }
     _receiving = true;
     return 0;
 }
 
 bool UdpTransportImpl::Receiving() const
 {
    return _receiving;
 }
 
@@ skipping 36 matching lines @@
         CriticalSectionScoped cs(_crit);
         _destPort = rtpPort;
         if(rtcpPort == 0)
         {
             _destPortRTCP = _destPort+1;
         } else
         {
             _destPortRTCP = rtcpPort;
         }
 
-        if(ipaddr == NULL)
-        {
-            if (!IsIpAddressValid(_destIP, IpV6Enabled()))
-            {
-                _destPort = 0;
-                _destPortRTCP = 0;
-                _lastError = kIpAddressInvalid;
-                return -1;
-            }
+        if (ipaddr == nullptr) {
+          if (!IsIpAddressValid(_destIP, IpV6Enabled())) {
+            _destPort = 0;
+            _destPortRTCP = 0;
+            _lastError = kIpAddressInvalid;
+            return -1;
+          }
         } else
         {
             if (IsIpAddressValid(ipaddr, IpV6Enabled()))
             {
                 strncpy(
                     _destIP,
                     ipaddr,
                     IpV6Enabled() ? kIpAddressVersion6Length :
                     kIpAddressVersion4Length);
             } else {
@@ skipping 46 matching lines @@
 
             // Set Time To Live to same region
             int32_t iOptVal = 64;
             if (!rtpSock->SetSockopt(IPPROTO_IP, IP_MULTICAST_TTL,
                                      (int8_t*)&iOptVal,
                                      sizeof (int32_t)))
             {
                 WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
                              "setsockopt for multicast error on RTP socket");
                 _ptrRtpSocket->CloseBlocking();
-                _ptrRtpSocket = NULL;
+                _ptrRtpSocket = nullptr;
                 _lastError = kMulticastAddressInvalid;
                 return -1;
             }
             if (!rtcpSock->SetSockopt(IPPROTO_IP, IP_MULTICAST_TTL,
                                       (int8_t*)&iOptVal,
                                       sizeof (int32_t)))
             {
                 WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
                              "setsockopt for multicast error on RTCP socket");
                 _ptrRtpSocket->CloseBlocking();
-                _ptrRtpSocket = NULL;
+                _ptrRtpSocket = nullptr;
                 _lastError = kMulticastAddressInvalid;
                 return -1;
             }
         }
     }
     return 0;
 }
 
 void UdpTransportImpl::BuildSockaddrIn(uint16_t portnr,
                                        const char* ip,
@@ skipping 28 matching lines @@
 
 int32_t UdpTransportImpl::SendRaw(const int8_t *data,
                                   size_t length,
                                   int32_t isRTCP,
                                   uint16_t portnr,
                                   const char* ip)
 {
     CriticalSectionScoped cs(_crit);
     if(isRTCP)
     {
-        UdpSocketWrapper* rtcpSock = NULL;
-        if(_ptrSendRtcpSocket)
-        {
-            rtcpSock = _ptrSendRtcpSocket;
+      UdpSocketWrapper* rtcpSock = nullptr;
+      if (_ptrSendRtcpSocket) {
+        rtcpSock = _ptrSendRtcpSocket;
         } else if(_ptrRtcpSocket)
         {
             rtcpSock = _ptrRtcpSocket;
         } else
         {
             return -1;
         }
-        if(portnr == 0 && ip == NULL)
-        {
-            return rtcpSock->SendTo(data,length,_remoteRTCPAddr);
+        if (portnr == 0 && ip == nullptr) {
+          return rtcpSock->SendTo(data, length, _remoteRTCPAddr);
 
-        } else if(portnr != 0 && ip != NULL)
-        {
-            SocketAddress remoteAddr;
-            BuildSockaddrIn(portnr, ip, remoteAddr);
-            return rtcpSock->SendTo(data,length,remoteAddr);
-        } else if(ip != NULL)
-        {
-            SocketAddress remoteAddr;
-            BuildSockaddrIn(_destPortRTCP, ip, remoteAddr);
-            return rtcpSock->SendTo(data,length,remoteAddr);
+        } else if (portnr != 0 && ip != nullptr) {
+          SocketAddress remoteAddr;
+          BuildSockaddrIn(portnr, ip, remoteAddr);
+          return rtcpSock->SendTo(data, length, remoteAddr);
+        } else if (ip != nullptr) {
+          SocketAddress remoteAddr;
+          BuildSockaddrIn(_destPortRTCP, ip, remoteAddr);
+          return rtcpSock->SendTo(data, length, remoteAddr);
         } else
         {
             SocketAddress remoteAddr;
             BuildSockaddrIn(portnr, _destIP, remoteAddr);
             return rtcpSock->SendTo(data,length,remoteAddr);
         }
     } else {
-        UdpSocketWrapper* rtpSock = NULL;
-        if(_ptrSendRtpSocket)
-        {
-            rtpSock = _ptrSendRtpSocket;
+      UdpSocketWrapper* rtpSock = nullptr;
+      if (_ptrSendRtpSocket) {
+        rtpSock = _ptrSendRtpSocket;
 
         } else if(_ptrRtpSocket)
         {
             rtpSock = _ptrRtpSocket;
         } else
         {
             return -1;
         }
-        if(portnr == 0 && ip == NULL)
-        {
-            return rtpSock->SendTo(data,length,_remoteRTPAddr);
+        if (portnr == 0 && ip == nullptr) {
+          return rtpSock->SendTo(data, length, _remoteRTPAddr);
 
-        } else if(portnr != 0 && ip != NULL)
-        {
-            SocketAddress remoteAddr;
-            BuildSockaddrIn(portnr, ip, remoteAddr);
-            return rtpSock->SendTo(data,length,remoteAddr);
-        } else if(ip != NULL)
-        {
-            SocketAddress remoteAddr;
-            BuildSockaddrIn(_destPort, ip, remoteAddr);
-            return rtpSock->SendTo(data,length,remoteAddr);
+        } else if (portnr != 0 && ip != nullptr) {
+          SocketAddress remoteAddr;
+          BuildSockaddrIn(portnr, ip, remoteAddr);
+          return rtpSock->SendTo(data, length, remoteAddr);
+        } else if (ip != nullptr) {
+          SocketAddress remoteAddr;
+          BuildSockaddrIn(_destPort, ip, remoteAddr);
+          return rtpSock->SendTo(data, length, remoteAddr);
         } else
         {
             SocketAddress remoteAddr;
             BuildSockaddrIn(portnr, _destIP, remoteAddr);
             return rtpSock->SendTo(data,length,remoteAddr);
         }
     }
 }
 
 int32_t UdpTransportImpl::SendRTPPacketTo(const int8_t* data,
@@ skipping 99 matching lines @@
         return false;
     }
     if(_destPort == 0)
     {
         return false;
     }
 
     // Create socket if it hasn't been set up already.
     // TODO (hellner): why not fail here instead. Sockets not being initialized
     //                 indicates that there is a problem somewhere.
-    if( _ptrSendRtpSocket == NULL &&
-        _ptrRtpSocket == NULL)
-    {
-        WEBRTC_TRACE(
-            kTraceStateInfo,
-            kTraceTransport,
-            _id,
-            "Creating RTP socket since no receive or source socket is\
+    if (_ptrSendRtpSocket == nullptr && _ptrRtpSocket == nullptr) {
+      WEBRTC_TRACE(kTraceStateInfo, kTraceTransport, _id,
+                   "Creating RTP socket since no receive or source socket is\
  configured");
 
-        _ptrRtpSocket = _socket_creator->CreateSocket(_id, _mgr, this,
-                                        IncomingRTPCallback,
-                                        IpV6Enabled(), false);
+      _ptrRtpSocket = _socket_creator->CreateSocket(
+          _id, _mgr, this, IncomingRTPCallback, IpV6Enabled(), false);
 
-        // Don't bind to a specific IP address.
-        if(! IpV6Enabled())
-        {
-            strncpy(_localIP, "0.0.0.0",16);
-        } else
-        {
-            strncpy(_localIP, "0000:0000:0000:0000:0000:0000:0000:0000",
-                    kIpAddressVersion6Length);
-        }
-        _localPort = _destPort;
+      // Don't bind to a specific IP address.
+      if (!IpV6Enabled()) {
+        strncpy(_localIP, "0.0.0.0", 16);
+      } else {
+        strncpy(_localIP, "0000:0000:0000:0000:0000:0000:0000:0000",
+                kIpAddressVersion6Length);
+      }
+      _localPort = _destPort;
 
-        ErrorCode retVal = BindLocalRTPSocket();
-        if(retVal != kNoSocketError)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
-                         "SendPacket() failed to bind RTP socket");
-            _lastError = retVal;
-            CloseReceiveSockets();
-            return false;
-        }
+      ErrorCode retVal = BindLocalRTPSocket();
+      if (retVal != kNoSocketError) {
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "SendPacket() failed to bind RTP socket");
+        _lastError = retVal;
+        CloseReceiveSockets();
+        return false;
+      }
     }
 
     if(_ptrSendRtpSocket)
     {
         return _ptrSendRtpSocket->SendTo((const int8_t*)data, length,
                                          _remoteRTPAddr) >= 0;
 
     } else if(_ptrRtpSocket)
     {
         return _ptrRtpSocket->SendTo((const int8_t*)data, length,
                                      _remoteRTPAddr) >= 0;
     }
     return false;
 }
 
 bool UdpTransportImpl::SendRtcp(const uint8_t* data, size_t length) {
     CriticalSectionScoped cs(_crit);
     if(_destIP[0] == 0)
     {
         return false;
     }
     if(_destPortRTCP == 0)
     {
         return false;
     }
 
     // Create socket if it hasn't been set up already.
     // TODO (hellner): why not fail here instead. Sockets not being initialized
     //                 indicates that there is a problem somewhere.
-    if( _ptrSendRtcpSocket == NULL &&
-        _ptrRtcpSocket == NULL)
-    {
-        WEBRTC_TRACE(
-            kTraceStateInfo,
-            kTraceTransport,
-            _id,
-            "Creating RTCP socket since no receive or source socket is\
+    if (_ptrSendRtcpSocket == nullptr && _ptrRtcpSocket == nullptr) {
+      WEBRTC_TRACE(kTraceStateInfo, kTraceTransport, _id,
+                   "Creating RTCP socket since no receive or source socket is\
  configured");
 
-        _ptrRtcpSocket = _socket_creator->CreateSocket(_id, _mgr, this,
-                                         IncomingRTCPCallback,
-                                         IpV6Enabled(), false);
+      _ptrRtcpSocket = _socket_creator->CreateSocket(
+          _id, _mgr, this, IncomingRTCPCallback, IpV6Enabled(), false);
 
-        // Don't bind to a specific IP address.
-        if(! IpV6Enabled())
-        {
-            strncpy(_localIP, "0.0.0.0",16);
-        } else
-        {
-            strncpy(_localIP, "0000:0000:0000:0000:0000:0000:0000:0000",
-                    kIpAddressVersion6Length);
-        }
-        _localPortRTCP = _destPortRTCP;
+      // Don't bind to a specific IP address.
+      if (!IpV6Enabled()) {
+        strncpy(_localIP, "0.0.0.0", 16);
+      } else {
+        strncpy(_localIP, "0000:0000:0000:0000:0000:0000:0000:0000",
+                kIpAddressVersion6Length);
+      }
+      _localPortRTCP = _destPortRTCP;
 
-        ErrorCode retVal = BindLocalRTCPSocket();
-        if(retVal != kNoSocketError)
-        {
-            _lastError = retVal;
-            WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
-                         "SendRtcp() failed to bind RTCP socket");
-            CloseReceiveSockets();
-            return false;
-        }
+      ErrorCode retVal = BindLocalRTCPSocket();
+      if (retVal != kNoSocketError) {
+        _lastError = retVal;
+        WEBRTC_TRACE(kTraceError, kTraceTransport, _id,
+                     "SendRtcp() failed to bind RTCP socket");
+        CloseReceiveSockets();
+        return false;
+      }
     }
 
     if(_ptrSendRtcpSocket)
     {
         return _ptrSendRtcpSocket->SendTo((const int8_t*)data, length,
                                           _remoteRTCPAddr) >= 0;
     } else if(_ptrRtcpSocket)
     {
         return _ptrRtcpSocket->SendTo((const int8_t*)data, length,
                                       _remoteRTCPAddr) >= 0;
@@ skipping 218 matching lines @@
         return false;
     }
     return true;
 }
 
 void UdpTransportImpl::CloseReceiveSockets()
 {
     if(_ptrRtpSocket)
     {
         _ptrRtpSocket->CloseBlocking();
-        _ptrRtpSocket = NULL;
+        _ptrRtpSocket = nullptr;
     }
     if(_ptrRtcpSocket)
     {
         _ptrRtcpSocket->CloseBlocking();
-        _ptrRtcpSocket = NULL;
+        _ptrRtcpSocket = nullptr;
     }
     _receiving = false;
 }
 
 void UdpTransportImpl::CloseSendSockets()
 {
     if(_ptrSendRtpSocket)
     {
         _ptrSendRtpSocket->CloseBlocking();
         _ptrSendRtpSocket = 0;
@@ skipping 70 matching lines @@
     }
 #else
     return -1;
 #endif
 }
 
 int32_t UdpTransport::LocalHostAddressIPV6(char n_localIP[16])
 {
 
 #if defined(_WIN32)
-    struct addrinfo *result = NULL;
-    struct addrinfo *ptr = NULL;
-    struct addrinfo hints;
+  struct addrinfo* result = nullptr;
+  struct addrinfo* ptr = nullptr;
+  struct addrinfo hints;
 
-    ZeroMemory(&hints, sizeof(hints));
-    hints.ai_family = AF_INET6;
+  ZeroMemory(&hints, sizeof(hints));
+  hints.ai_family = AF_INET6;
 
-    char szHostName[256] = "";
-    if(::gethostname(szHostName, sizeof(szHostName) - 1))
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1, "gethostname failed");
-        return -1;
+  char szHostName[256] = "";
+  if (::gethostname(szHostName, sizeof(szHostName) - 1)) {
+    WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1, "gethostname failed");
+    return -1;
     }
 
-    DWORD dwRetval = getaddrinfo(szHostName, NULL, &hints, &result);
+    DWORD dwRetval = getaddrinfo(szHostName, nullptr, &hints, &result);
     if ( dwRetval != 0 )
     {
         WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1,
                      "getaddrinfo failed, error:%d", dwRetval);
         return -1;
     }
-    for(ptr=result; ptr != NULL ;ptr=ptr->ai_next)
-    {
-        switch (ptr->ai_family)
-        {
-            case AF_INET6:
-                {
-                    for(int i = 0; i< 16; i++)
-                    {
-                        n_localIP[i] = (*(SocketAddress*)ptr->ai_addr).
-                            _sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u8[i];
-                    }
-                    bool islocalIP = true;
+    for (ptr = result; ptr != nullptr; ptr = ptr->ai_next) {
+      switch (ptr->ai_family) {
+        case AF_INET6: {
+          for (int i = 0; i < 16; i++) {
+            n_localIP[i] =
+                (*(SocketAddress*)ptr->ai_addr)
+                    ._sockaddr_in6.sin6_addr.Version6AddressUnion._s6_u8[i];
+          }
+          bool islocalIP = true;
 
-                    for(int n = 0; n< 15; n++)
-                    {
-                        if(n_localIP[n] != 0)
-                        {
-                            islocalIP = false;
-                            break;
-                        }
-                    }
+          for (int n = 0; n < 15; n++) {
+            if (n_localIP[n] != 0) {
+              islocalIP = false;
+              break;
+            }
+          }
 
-                    if(islocalIP && n_localIP[15] != 1)
-                    {
-                        islocalIP = false;
-                    }
+          if (islocalIP && n_localIP[15] != 1) {
+            islocalIP = false;
+          }
 
-                    if(islocalIP && ptr->ai_next)
-                    {
-                        continue;
-                    }
-                    if(n_localIP[0] == 0xfe &&
-                       n_localIP[1] == 0x80 && ptr->ai_next)
-                    {
-                        continue;
-                    }
-                    freeaddrinfo(result);
-                }
-                return 0;
-            default:
-                break;
-        };
+          if (islocalIP && ptr->ai_next) {
+            continue;
+          }
+          if (n_localIP[0] == 0xfe && n_localIP[1] == 0x80 && ptr->ai_next) {
+            continue;
+          }
+          freeaddrinfo(result);
+        }
+          return 0;
+        default:
+          break;
+      };
     }
     freeaddrinfo(result);
     WEBRTC_TRACE(kTraceWarning, kTraceTransport, -1,
                  "getaddrinfo failed to find address");
     return -1;
 
 #elif defined(WEBRTC_MAC)
-    struct ifaddrs* ptrIfAddrs = NULL;
-    struct ifaddrs* ptrIfAddrsStart = NULL;
+  struct ifaddrs* ptrIfAddrs = nullptr;
+  struct ifaddrs* ptrIfAddrsStart = nullptr;
 
-    getifaddrs(&ptrIfAddrsStart);
-    ptrIfAddrs = ptrIfAddrsStart;
-    while(ptrIfAddrs)
-    {
-        if(ptrIfAddrs->ifa_addr->sa_family == AF_INET6)
-        {
-            const struct sockaddr_in6* sock_in6 =
-                reinterpret_cast<struct sockaddr_in6*>(ptrIfAddrs->ifa_addr);
-            const struct in6_addr* sin6_addr = &sock_in6->sin6_addr;
+  getifaddrs(&ptrIfAddrsStart);
+  ptrIfAddrs = ptrIfAddrsStart;
+  while (ptrIfAddrs) {
+    if (ptrIfAddrs->ifa_addr->sa_family == AF_INET6) {
+      const struct sockaddr_in6* sock_in6 =
+          reinterpret_cast<struct sockaddr_in6*>(ptrIfAddrs->ifa_addr);
+      const struct in6_addr* sin6_addr = &sock_in6->sin6_addr;
 
-            if (IN6_IS_ADDR_LOOPBACK(sin6_addr) ||
-                IN6_IS_ADDR_LINKLOCAL(sin6_addr)) {
-                ptrIfAddrs = ptrIfAddrs->ifa_next;
-                continue;
-            }
-            memcpy(n_localIP, sin6_addr->s6_addr, sizeof(sin6_addr->s6_addr));
-            freeifaddrs(ptrIfAddrsStart);
-            return 0;
-        }
+      if (IN6_IS_ADDR_LOOPBACK(sin6_addr) || IN6_IS_ADDR_LINKLOCAL(sin6_addr)) {
         ptrIfAddrs = ptrIfAddrs->ifa_next;
+        continue;
+      }
+      memcpy(n_localIP, sin6_addr->s6_addr, sizeof(sin6_addr->s6_addr));
+      freeifaddrs(ptrIfAddrsStart);
+      return 0;
+    }
+    ptrIfAddrs = ptrIfAddrs->ifa_next;
     }
     freeifaddrs(ptrIfAddrsStart);
     return -1;
 #elif defined(WEBRTC_ANDROID)
     return -1;
 #else // WEBRTC_LINUX
     struct
     {
         struct nlmsghdr n;
         struct ifaddrmsg r;
     } req;
 
-    struct rtattr* rta = NULL;
+    struct rtattr* rta = nullptr;
     int status;
     char buf[16384]; // = 16 * 1024 (16 kB)
     struct nlmsghdr* nlmp;
     struct ifaddrmsg* rtmp;
     struct rtattr* rtatp;
     int rtattrlen;
     struct in6_addr* in6p;
 
     int fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
     if (fd == -1)
@@ skipping 168 matching lines @@
 #else // WEBRTC_LINUX
     int sockfd, size  = 1;
     struct ifreq* ifr;
     struct ifconf ifc;
 
     if (0 > (sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)))
     {
       return -1;
     }
     ifc.ifc_len = IFRSIZE;
-    ifc.ifc_req = NULL;
+    ifc.ifc_req = nullptr;
     do
     {
         ++size;
         // Buffer size needed is unknown. Try increasing it until no overflow
         // occurs.
-        if (NULL == (ifc.ifc_req = (ifreq*)realloc(ifc.ifc_req, IFRSIZE))) {
+        if (nullptr == (ifc.ifc_req = (ifreq*)realloc(ifc.ifc_req, IFRSIZE))) {
           fprintf(stderr, "Out of memory.\n");
           exit(EXIT_FAILURE);
         }
         ifc.ifc_len = IFRSIZE;
         if (ioctl(sockfd, SIOCGIFCONF, &ifc))
         {
             free(ifc.ifc_req);
             close(sockfd);
             return -1;
         }
@@ skipping 30 matching lines @@
 #endif
 }
 
 int32_t UdpTransport::IPAddress(const SocketAddress& address,
                                 char* ip,
                                 uint32_t& ipSize,
                                 uint16_t& sourcePort)
 {
  #if defined(_WIN32)
     DWORD dwIPSize = ipSize;
-    int32_t returnvalue = WSAAddressToStringA((LPSOCKADDR)(&address),
-                                         sizeof(SocketAddress),
-                                         NULL,
-                                         ip,
-                                         &dwIPSize);
+    int32_t returnvalue = WSAAddressToStringA(
+        (LPSOCKADDR)(&address), sizeof(SocketAddress), nullptr, ip, &dwIPSize);
     if(returnvalue == -1)
     {
         return -1;
     }
 
     uint16_t source_port = 0;
     if(address._sockaddr_storage.sin_family == AF_INET)
     {
         // Parse IP assuming format "a.b.c.d:port".
         char* ipEnd = strchr(ip,':');
-        if(ipEnd != NULL)
-        {
-            *ipEnd = '\0';
+        if (ipEnd != nullptr) {
+          *ipEnd = '\0';
         }
         ipSize = (int32_t)strlen(ip);
         if(ipSize == 0)
         {
             return -1;
         }
         source_port = address._sockaddr_in.sin_port;
     }
     else
     {
         // Parse IP assuming format "[address]:port".
         char* ipEnd = strchr(ip,']');
-        if(ipEnd != NULL)
-        {
+        if (ipEnd != nullptr) {
           // Calculate length
             int32_t adrSize = int32_t(ipEnd - ip) - 1;
             memmove(ip, &ip[1], adrSize);   // Remove '['
             *(ipEnd - 1) = '\0';
         }
         ipSize = (int32_t)strlen(ip);
         if(ipSize == 0)
         {
             return -1;
         }
 
         source_port = address._sockaddr_in6.sin6_port;
     }
     // Convert port number to network byte order.
     sourcePort = htons(source_port);
     return 0;
 
  #elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
     int32_t ipFamily = address._sockaddr_storage.sin_family;
-    const void* ptrNumericIP = NULL;
+    const void* ptrNumericIP = nullptr;
 
     if(ipFamily == AF_INET)
     {
         ptrNumericIP = &(address._sockaddr_in.sin_addr);
     }
     else if(ipFamily == AF_INET6)
     {
         ptrNumericIP = &(address._sockaddr_in6.sin6_addr);
     }
     else
     {
         return -1;
     }
-    if(inet_ntop(ipFamily, ptrNumericIP, ip, ipSize) == NULL)
-    {
-        return -1;
+    if (inet_ntop(ipFamily, ptrNumericIP, ip, ipSize) == nullptr) {
+      return -1;
     }
     uint16_t source_port;
     if(ipFamily == AF_INET)
     {
         source_port = address._sockaddr_in.sin_port;
     } else
     {
         source_port = address._sockaddr_in6.sin6_port;
     }
     // Convert port number to network byte order.
@@ skipping 187 matching lines @@
         if (nDots != 3 || !allUnder256)
         {
             return false;
         }
     }
     return true;
 }
 
 }  // namespace test
 }  // namespace webrtc