[Sync] Replacing NULL with nullptr in code and null in comments for components/sync/

components/sync/base/weak_handle.h

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Weak handles provides a way to refer to weak pointers from another
 // thread.  This is useful because it is not safe to reference a weak
 // pointer from a thread other than the thread on which it was
 // created.
 //
 // Weak handles can be passed across threads, so for example, you can
@@ skipping 140 matching lines @@
       : core_(new internal::WeakHandleCore<T>(ptr)) {}
 
   // Allow conversion from WeakHandle<U> to WeakHandle<T> if U is
   // convertible to T, but we *must* be on |other|'s owner thread.
   // Note that this doesn't override the regular copy constructor, so
   // that one can be called on any thread.
   template <typename U>
   WeakHandle(const WeakHandle<U>& other)  // NOLINT
       : core_(other.IsInitialized()
                   ? new internal::WeakHandleCore<T>(other.Get())
-                  : NULL) {}
+                  : nullptr) {}
 
   // Returns true iff this WeakHandle is initialized.  Note that being
   // initialized isn't a guarantee that the underlying object is still
   // alive.
-  bool IsInitialized() const { return core_.get() != NULL; }
+  bool IsInitialized() const { return core_.get() != nullptr; }
 
   // Resets to an uninitialized WeakHandle.
-  void Reset() { core_ = NULL; }
+  void Reset() { core_ = nullptr; }
 
   // Must be called only on the underlying object's owner thread.
   base::WeakPtr<T> Get() const {
     CHECK(IsInitialized());
     CHECK(core_->IsOnOwnerThread());
     return core_->Get();
   }
 
   // Call(...) may be called on any thread, but all its arguments
   // should be safe to be bound and copied across threads.
@@ skipping 14 matching lines @@
 
 // Makes a WeakHandle from a WeakPtr.
 template <typename T>
 WeakHandle<T> MakeWeakHandle(const base::WeakPtr<T>& ptr) {
   return WeakHandle<T>(ptr);
 }
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_BASE_WEAK_HANDLE_H_