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

webrtc/base/physicalsocketserver_unittest.cc

 /*
  *  Copyright 2004 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 465 matching lines @@
     signals_received_.push_back(signum);
     signaled_thread_ = Thread::Current();
   }
 
  protected:
   void SetUp() {
     ss_.reset(new PhysicalSocketServer());
   }
 
   void TearDown() {
-    ss_.reset(NULL);
+    ss_.reset(nullptr);
     signals_received_.clear();
-    signaled_thread_ = NULL;
+    signaled_thread_ = nullptr;
   }
 
   bool ExpectSignal(int signum) {
     if (signals_received_.empty()) {
       LOG(LS_ERROR) << "ExpectSignal(): No signal received";
       return false;
     }
     if (signals_received_[0] != signum) {
       LOG(LS_ERROR) << "ExpectSignal(): Received signal " <<
           signals_received_[0] << ", expected " << signum;
@@ skipping 12 matching lines @@
     return ret;
   }
 
   static std::vector<int> signals_received_;
   static Thread *signaled_thread_;
 
   std::unique_ptr<PhysicalSocketServer> ss_;
 };
 
 std::vector<int> PosixSignalDeliveryTest::signals_received_;
-Thread *PosixSignalDeliveryTest::signaled_thread_ = NULL;
+Thread* PosixSignalDeliveryTest::signaled_thread_ = nullptr;
 
 // Test receiving a synchronous signal while not in Wait() and then entering
 // Wait() afterwards.
 TEST_F(PosixSignalDeliveryTest, RaiseThenWait) {
   ASSERT_TRUE(ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal));
   raise(SIGTERM);
   EXPECT_TRUE(ss_->Wait(0, true));
   EXPECT_TRUE(ExpectSignal(SIGTERM));
   EXPECT_TRUE(ExpectNone());
 }
@@ skipping 24 matching lines @@
 }
 
 class RaiseSigTermRunnable : public Runnable {
   void Run(Thread *thread) {
     thread->socketserver()->Wait(1000, false);
 
     // Allow SIGTERM. This will be the only thread with it not masked so it will
     // be delivered to us.
     sigset_t mask;
     sigemptyset(&mask);
-    pthread_sigmask(SIG_SETMASK, &mask, NULL);
+    pthread_sigmask(SIG_SETMASK, &mask, nullptr);
 
     // Raise it.
     raise(SIGTERM);
   }
 };
 
 // Test that it works no matter what thread the kernel chooses to give the
 // signal to (since it's not guaranteed to be the one that Wait() runs on).
 TEST_F(PosixSignalDeliveryTest, SignalOnDifferentThread) {
   ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
   // Mask out SIGTERM so that it can't be delivered to this thread.
   sigset_t mask;
   sigemptyset(&mask);
   sigaddset(&mask, SIGTERM);
-  EXPECT_EQ(0, pthread_sigmask(SIG_SETMASK, &mask, NULL));
+  EXPECT_EQ(0, pthread_sigmask(SIG_SETMASK, &mask, nullptr));
   // Start a new thread that raises it. It will have to be delivered to that
   // thread. Our implementation should safely handle it and dispatch
   // RecordSignal() on this thread.
   std::unique_ptr<Thread> thread(new Thread());
   std::unique_ptr<RaiseSigTermRunnable> runnable(new RaiseSigTermRunnable());
   thread->Start(runnable.get());
   EXPECT_TRUE(ss_->Wait(1500, true));
   EXPECT_TRUE(ExpectSignal(SIGTERM));
   EXPECT_EQ(Thread::Current(), signaled_thread_);
   EXPECT_TRUE(ExpectNone());
 }
 
 #endif
 
 }  // namespace rtc