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

components/sync/syncable/mutable_entry.cc

 // 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.
 
 #include "components/sync/syncable/mutable_entry.h"
 
 #include <memory>
 
 #include "components/sync/base/unique_position.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/scoped_kernel_lock.h"
 #include "components/sync/syncable/scoped_parent_child_index_updater.h"
 #include "components/sync/syncable/syncable_changes_version.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "components/sync/syncable/syncable_write_transaction.h"
 
 using std::string;
 
 namespace syncer {
 namespace syncable {
 
 void MutableEntry::Init(WriteTransaction* trans,
                         ModelType model_type,
                         const Id& parent_id,
                         const string& name) {
   std::unique_ptr<EntryKernel> kernel(new EntryKernel);
-  kernel_ = NULL;
+  kernel_ = nullptr;
 
   kernel->put(ID, trans->directory_->NextId());
   kernel->put(META_HANDLE, trans->directory_->NextMetahandle());
   kernel->mark_dirty(&trans->directory_->kernel()->dirty_metahandles);
   kernel->put(NON_UNIQUE_NAME, name);
   const base::Time& now = base::Time::Now();
   kernel->put(CTIME, now);
   kernel->put(MTIME, now);
   // We match the database defaults here
   kernel->put(BASE_VERSION, CHANGES_VERSION);
@@ skipping 205 matching lines @@
     ScopedKernelLock lock(dir());
     ScopedParentChildIndexUpdater updater(lock, kernel_,
                                           &dir()->kernel()->parent_child_index);
     kernel_->put(UNIQUE_POSITION, value);
     MarkDirty();
   }
 }
 
 bool MutableEntry::PutPredecessor(const Id& predecessor_id) {
   if (predecessor_id.IsNull()) {
-    dir()->PutPredecessor(kernel_, NULL);
+    dir()->PutPredecessor(kernel_, nullptr);
   } else {
     MutableEntry predecessor(write_transaction(), GET_BY_ID, predecessor_id);
     if (!predecessor.good())
       return false;
     dir()->PutPredecessor(kernel_, predecessor.kernel_);
     // No need to make the entry dirty here because setting the predecessor
     // results in PutUniquePosition call (which might or might not make the
     // entry dirty).
   }
   return true;
@@ skipping 34 matching lines @@
       continue;
     record->set_is_on_server(true);
   }
   kernel_->put(ATTACHMENT_METADATA, attachment_metadata);
   MarkDirty();
   MarkForSyncing(this);
 }
 
 // This function sets only the flags needed to get this entry to sync.
 bool MarkForSyncing(MutableEntry* e) {
-  DCHECK_NE(static_cast<MutableEntry*>(NULL), e);
+  DCHECK_NE(static_cast<MutableEntry*>(nullptr), e);
   DCHECK(!e->IsRoot()) << "We shouldn't mark a permanent object for syncing.";
   if (!(e->PutIsUnsynced(true)))
     return false;
   if (e->GetSyncing())
     e->PutDirtySync(true);
   return true;
 }
 
 }  // namespace syncable
 }  // namespace syncer