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

webrtc/base/scoped_ref_ptr.h

 /*
  *  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 12 matching lines @@
 //
 //   void some_function() {
 //     scoped_refptr<MyFoo> foo = new MyFoo();
 //     foo->Method(param);
 //     // |foo| is released when this function returns
 //   }
 //
 //   void some_other_function() {
 //     scoped_refptr<MyFoo> foo = new MyFoo();
 //     ...
-//     foo = NULL;  // explicitly releases |foo|
+//     foo = nullptr;  // explicitly releases |foo|
 //     ...
 //     if (foo)
 //       foo->Method(param);
 //   }
 //
 // The above examples show how scoped_refptr<T> acts like a pointer to T.
 // Given two scoped_refptr<T> classes, it is also possible to exchange
 // references between the two objects, like so:
 //
 //   {
 //     scoped_refptr<MyFoo> a = new MyFoo();
 //     scoped_refptr<MyFoo> b;
 //
 //     b.swap(a);
-//     // now, |b| references the MyFoo object, and |a| references NULL.
+//     // now, |b| references the MyFoo object, and |a| references null.
 //   }
 //
 // To make both |a| and |b| in the above example reference the same MyFoo
 // object, simply use the assignment operator:
 //
 //   {
 //     scoped_refptr<MyFoo> a = new MyFoo();
 //     scoped_refptr<MyFoo> b;
 //
 //     b = a;
 //     // now, |a| and |b| each own a reference to the same MyFoo object.
 //   }
 //
 
 #ifndef WEBRTC_BASE_SCOPED_REF_PTR_H_
 #define WEBRTC_BASE_SCOPED_REF_PTR_H_
 
 #include <memory>
 
 namespace rtc {
 
 template <class T>
 class scoped_refptr {
  public:
-  scoped_refptr() : ptr_(NULL) {
-  }
+  scoped_refptr() : ptr_(nullptr) {}
 
   scoped_refptr(T* p) : ptr_(p) {
     if (ptr_)
       ptr_->AddRef();
   }
 
   scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
     if (ptr_)
       ptr_->AddRef();
   }
@@ skipping 14 matching lines @@
     if (ptr_)
       ptr_->Release();
   }
 
   T* get() const { return ptr_; }
   operator T*() const { return ptr_; }
   T* operator->() const { return ptr_; }
 
   // Release a pointer.
   // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
+  // If this object holds a null pointer, the return value is null.
+  // After this operation, this object will hold a null pointer,
   // and will not own the object any more.
   T* release() {
     T* retVal = ptr_;
-    ptr_ = NULL;
+    ptr_ = nullptr;
     return retVal;
   }
 
   scoped_refptr<T>& operator=(T* p) {
     // AddRef first so that self assignment should work
     if (p)
       p->AddRef();
     if (ptr_ )
       ptr_ ->Release();
     ptr_ = p;
@@ skipping 30 matching lines @@
     swap(&r.ptr_);
   }
 
  protected:
   T* ptr_;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_SCOPED_REF_PTR_H_