Replace NULL with nullptr or null in webrtc/base/.

webrtc/base/sslstreamadapter_unittest.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 207 matching lines @@
   SSLStreamAdapterTestBase(
       const std::string& client_cert_pem,
       const std::string& client_private_key_pem,
       bool dtls,
       rtc::KeyParams client_key_type = rtc::KeyParams(rtc::KT_DEFAULT),
       rtc::KeyParams server_key_type = rtc::KeyParams(rtc::KT_DEFAULT))
       : client_cert_pem_(client_cert_pem),
         client_private_key_pem_(client_private_key_pem),
         client_key_type_(client_key_type),
         server_key_type_(server_key_type),
-        client_stream_(NULL),
-        server_stream_(NULL),
-        client_identity_(NULL),
-        server_identity_(NULL),
+        client_stream_(nullptr),
+        server_stream_(nullptr),
+        client_identity_(nullptr),
+        server_identity_(nullptr),
         delay_(0),
         mtu_(1460),
         loss_(0),
         lose_first_packet_(false),
         damage_(false),
         dtls_(dtls),
         handshake_wait_(5000),
         identities_set_(false) {
     // Set use of the test RNG to get predictable loss patterns.
     rtc::SetRandomTestMode(true);
@@ skipping 378 matching lines @@
 
   // Test data transfer for TLS
   void TestTransfer(int size) override {
     LOG(LS_INFO) << "Starting transfer test with " << size << " bytes";
     // Create some dummy data to send.
     size_t received;
 
     send_stream_.ReserveSize(size);
     for (int i = 0; i < size; ++i) {
       char ch = static_cast<char>(i);
-      send_stream_.Write(&ch, 1, NULL, NULL);
+      send_stream_.Write(&ch, 1, nullptr, nullptr);
     }
     send_stream_.Rewind();
 
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
 
     // Start sending
     WriteData();
 
     // Wait for the client to close
@@ skipping 12 matching lines @@
     rtc::StreamResult rv;
     size_t sent;
     char block[kBlockSize];
 
     send_stream_.GetSize(&size);
     if (!size)
       return;
 
     for (;;) {
       send_stream_.GetPosition(&position);
-      if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
+      if (send_stream_.Read(block, sizeof(block), &tosend, nullptr) !=
           rtc::SR_EOS) {
         rv = client_ssl_->Write(block, tosend, &sent, 0);
 
         if (rv == rtc::SR_SUCCESS) {
           send_stream_.SetPosition(position + sent);
           LOG(LS_VERBOSE) << "Sent: " << position + sent;
         } else if (rv == rtc::SR_BLOCK) {
           LOG(LS_VERBOSE) << "Blocked...";
           send_stream_.SetPosition(position);
           break;
@@ skipping 25 matching lines @@
         stream->Close();
         return;
       }
 
       if (r == rtc::SR_BLOCK)
         break;
 
       ASSERT_EQ(rtc::SR_SUCCESS, r);
       LOG(LS_VERBOSE) << "Read " << bread;
 
-      recv_stream_.Write(buffer, bread, NULL, NULL);
+      recv_stream_.Write(buffer, bread, nullptr, nullptr);
     }
   }
 
  private:
   rtc::FifoBuffer client_buffer_;
   rtc::FifoBuffer server_buffer_;
   rtc::MemoryStream send_stream_;
   rtc::MemoryStream recv_stream_;
 };
 
@@ skipping 169 matching lines @@
 TEST_P(SSLStreamAdapterTestTLS, ReadWriteAfterClose) {
   TestHandshake();
   TestTransfer(100000);
   client_ssl_->Close();
 
   rtc::StreamResult rv;
   char block[kBlockSize];
   size_t dummy;
 
   // It's an error to write after closed.
-  rv = client_ssl_->Write(block, sizeof(block), &dummy, NULL);
+  rv = client_ssl_->Write(block, sizeof(block), &dummy, nullptr);
   ASSERT_EQ(rtc::SR_ERROR, rv);
 
   // But after closed read gives you EOS.
-  rv = client_ssl_->Read(block, sizeof(block), &dummy, NULL);
+  rv = client_ssl_->Read(block, sizeof(block), &dummy, nullptr);
   ASSERT_EQ(rtc::SR_EOS, rv);
 };
 
 // Test a handshake with a bogus peer digest
 TEST_P(SSLStreamAdapterTestTLS, TestTLSBogusDigest) {
   SetPeerIdentitiesByDigest(false, true);
   TestHandshake(false);
 };
 
 TEST_P(SSLStreamAdapterTestTLS, TestTLSDelayedIdentity) {
@@ skipping 429 matching lines @@
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));
 INSTANTIATE_TEST_CASE_P(
     SSLStreamAdapterTestsDTLS,
     SSLStreamAdapterTestDTLS,
     Combine(Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256)),
             Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));