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

webrtc/base/ssladapter_unittest.cc

 /*
  *  Copyright 2014 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 147 matching lines @@
     // Since we don't have a real certificate anyway, the value here doesn't
     // really matter.
     return "example.com";
   }
 
   const std::string& GetReceivedData() const {
     return data_;
   }
 
   int Send(const std::string& message) {
-    if (ssl_stream_adapter_ == NULL
-        || ssl_stream_adapter_->GetState() != rtc::SS_OPEN) {
+    if (ssl_stream_adapter_ == nullptr ||
+        ssl_stream_adapter_->GetState() != rtc::SS_OPEN) {
       // No connection yet.
       return -1;
     }
 
     LOG(LS_INFO) << "Server sending '" << message << "'";
 
     size_t written;
     int error;
 
     rtc::StreamResult r = ssl_stream_adapter_->Write(message.data(),
         message.length(), &written, &error);
     if (r == rtc::SR_SUCCESS) {
       return written;
     } else {
       return -1;
     }
   }
 
   void AcceptConnection(const rtc::SocketAddress& address) {
     // Only a single connection is supported.
-    ASSERT_TRUE(ssl_stream_adapter_ == NULL);
+    ASSERT_TRUE(ssl_stream_adapter_ == nullptr);
 
     // This is only for DTLS.
     ASSERT_EQ(rtc::SSL_MODE_DTLS, ssl_mode_);
 
     // Transfer ownership of the socket to the SSLStreamAdapter object.
     rtc::AsyncSocket* socket = server_socket_.release();
 
     socket->Connect(address);
 
     DoHandshake(socket);
   }
 
   void OnServerSocketReadEvent(rtc::AsyncSocket* socket) {
     // Only a single connection is supported.
-    ASSERT_TRUE(ssl_stream_adapter_ == NULL);
+    ASSERT_TRUE(ssl_stream_adapter_ == nullptr);
 
-    DoHandshake(server_socket_->Accept(NULL));
+    DoHandshake(server_socket_->Accept(nullptr));
   }
 
   void OnSSLStreamAdapterEvent(rtc::StreamInterface* stream, int sig, int err) {
     if (sig & rtc::SE_READ) {
       char buffer[4096] = "";
 
       size_t read;
       int error;
 
       // Read data received from the client and store it in our internal
@@ skipping 49 matching lines @@
 
   std::string data_;
 };
 
 class SSLAdapterTestBase : public testing::Test,
                            public sigslot::has_slots<> {
  public:
   explicit SSLAdapterTestBase(const rtc::SSLMode& ssl_mode,
                               const rtc::KeyParams& key_params)
       : ssl_mode_(ssl_mode),
-        ss_scope_(new rtc::VirtualSocketServer(NULL)),
+        ss_scope_(new rtc::VirtualSocketServer(nullptr)),
         server_(new SSLAdapterTestDummyServer(ssl_mode_, key_params)),
         client_(new SSLAdapterTestDummyClient(ssl_mode_)),
         handshake_wait_(kTimeout) {}
 
   void SetHandshakeWait(int wait) {
     handshake_wait_ = wait;
   }
 
   void TestHandshake(bool expect_success) {
     int rv;
@@ skipping 122 matching lines @@
 TEST_F(SSLAdapterTestDTLS_RSA, TestDTLSTransfer) {
   TestHandshake(true);
   TestTransfer("Hello, world!");
 }
 
 // Test transfer between client and server, using ECDSA
 TEST_F(SSLAdapterTestDTLS_ECDSA, TestDTLSTransfer) {
   TestHandshake(true);
   TestTransfer("Hello, world!");
 }