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

components/sync/syncable/directory.h

 // Copyright 2013 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.
 
 #ifndef COMPONENTS_SYNC_SYNCABLE_DIRECTORY_H_
 #define COMPONENTS_SYNC_SYNCABLE_DIRECTORY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 91 matching lines @@
     // Later out-of-sync models can be detected and fixed by comparing
     // transaction versions of sync model and native model.
     // TODO(hatiaol): implement detection and fixing of out-of-sync models.
     //                Bug 154858.
     int64_t transaction_version[MODEL_TYPE_COUNT];
     // The store birthday we were given by the server. Contents are opaque to
     // the client.
     std::string store_birthday;
     // The serialized bag of chips we were given by the server. Contents are
     // opaque to the client. This is the serialization of a message of type
-    // ChipBag defined in sync.proto. It can contains NULL characters.
+    // ChipBag defined in sync.proto. It can contains null characters.
     std::string bag_of_chips;
     // The per-datatype context.
     sync_pb::DataTypeContext datatype_context[MODEL_TYPE_COUNT];
   };
 
   // What the Directory needs on initialization to create itself and its Kernel.
   // Filled by DirectoryBackingStore::Load.
   struct KernelLoadInfo {
     PersistedKernelInfo kernel_info;
     std::string cache_guid;  // Created on first initialization, never changes.
@@ skipping 13 matching lines @@
 
     KernelShareInfoStatus kernel_info_status;
     PersistedKernelInfo kernel_info;
     OwnedEntryKernelSet dirty_metas;
     MetahandleSet metahandles_to_purge;
     OwnedEntryKernelSet delete_journals;
     MetahandleSet delete_journals_to_purge;
   };
 
   struct Kernel {
-    // |delegate| must not be NULL.  |transaction_observer| must be
+    // |delegate| must not be null.  |transaction_observer| must be
     // initialized.
     Kernel(const std::string& name,
            const KernelLoadInfo& info,
            DirectoryChangeDelegate* delegate,
            const WeakHandle<TransactionObserver>& transaction_observer);
 
     ~Kernel();
 
     // Implements ReadTransaction / WriteTransaction using a simple lock.
     base::Lock transaction_mutex;
@@ skipping 71 matching lines @@
     // unique server IDs. No need to lock, only written at init time.
     const std::string cache_guid;
 
     // It doesn't make sense for two threads to run SaveChanges at the same
     // time; this mutex protects that activity.
     base::Lock save_changes_mutex;
 
     // The next metahandle is protected by kernel mutex.
     int64_t next_metahandle;
 
-    // The delegate for directory change events.  Must not be NULL.
+    // The delegate for directory change events.  Must not be null.
     DirectoryChangeDelegate* const delegate;
 
     // The transaction observer.
     const WeakHandle<TransactionObserver> transaction_observer;
   };
 
   // Does not take ownership of |encryptor|.
-  // |report_unrecoverable_error_function| may be NULL.
+  // |report_unrecoverable_error_function| may be null.
   // Takes ownership of |store|.
   Directory(
       DirectoryBackingStore* store,
       const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
       const base::Closure& report_unrecoverable_error_function,
       NigoriHandler* nigori_handler,
       Cryptographer* cryptographer);
   virtual ~Directory();
 
-  // Does not take ownership of |delegate|, which must not be NULL.
+  // Does not take ownership of |delegate|, which must not be null.
   // Starts sending events to |delegate| if the returned result is
   // OPENED.  Note that events to |delegate| may be sent from *any*
   // thread.  |transaction_observer| must be initialized.
   DirOpenResult Open(
       const std::string& name,
       DirectoryChangeDelegate* delegate,
       const WeakHandle<TransactionObserver>& transaction_observer);
 
   int64_t NextMetahandle();
   // Generates next client ID based on a randomly generated GUID.
   syncable::Id NextId();
 
-  bool good() const { return NULL != kernel_; }
+  bool good() const { return nullptr != kernel_; }
 
   // The download progress is an opaque token provided by the sync server
   // to indicate the continuation state of the next GetUpdates operation.
   void GetDownloadProgress(ModelType type,
                            sync_pb::DataTypeProgressMarker* value_out) const;
   void GetDownloadProgressAsString(ModelType type,
                                    std::string* value_out) const;
   void SetDownloadProgress(ModelType type,
                            const sync_pb::DataTypeProgressMarker& value);
   bool HasEmptyDownloadProgress(ModelType type) const;
@@ skipping 83 matching lines @@
 
   // These functions allow one to fetch the next or previous item under
   // the same folder.  Returns the "root" ID if there is no predecessor
   // or successor.
   //
   // TODO(rlarocque): These functions are used mainly for tree traversal.  We
   // should replace these with an iterator API.  See crbug.com/178275.
   syncable::Id GetPredecessorId(EntryKernel* e);
   syncable::Id GetSuccessorId(EntryKernel* e);
 
-  // Places |e| as a successor to |predecessor|.  If |predecessor| is NULL,
+  // Places |e| as a successor to |predecessor|.  If |predecessor| is null,
   // |e| will be placed as the left-most item in its folder.
   //
   // Both |e| and |predecessor| must be valid entries under the same parent.
   //
   // TODO(rlarocque): This function includes limited support for placing items
   // with valid positions (ie. Bookmarks) as siblings of items that have no set
   // ordering (ie. Autofill items).  This support is required only for tests,
   // and should be removed.  See crbug.com/178282.
   void PutPredecessor(EntryKernel* e, EntryKernel* predecessor);
 
@@ skipping 268 matching lines @@
 
   base::WeakPtrFactory<Directory> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Directory);
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_SYNCABLE_DIRECTORY_H_