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

components/sync/syncable/model_neutral_mutable_entry.cc

 // 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.
 
 #include "components/sync/syncable/model_neutral_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/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 {
 
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(BaseWriteTransaction* trans,
                                                    CreateNewUpdateItem,
                                                    const Id& id)
     : Entry(trans), base_write_transaction_(trans) {
   Entry same_id(trans, GET_BY_ID, id);
-  kernel_ = NULL;
+  kernel_ = nullptr;
   if (same_id.good()) {
     return;  // already have an item with this ID.
   }
   std::unique_ptr<EntryKernel> kernel(new EntryKernel());
 
   kernel->put(ID, id);
   kernel->put(META_HANDLE, trans->directory()->NextMetahandle());
   kernel->mark_dirty(&trans->directory()->kernel()->dirty_metahandles);
   kernel->put(IS_DEL, true);
   // We match the database defaults here
   kernel->put(BASE_VERSION, CHANGES_VERSION);
   if (!trans->directory()->InsertEntry(trans, kernel.get())) {
     return;  // Failed inserting.
   }
   trans->TrackChangesTo(kernel.get());
 
   kernel_ = kernel.release();
 }
 
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(BaseWriteTransaction* trans,
                                                    CreateNewTypeRoot,
                                                    ModelType type)
     : Entry(trans), base_write_transaction_(trans) {
   // We allow NIGORI because we allow SyncEncryptionHandler to restore a nigori
   // across Directory instances (see SyncEncryptionHandler::RestoreNigori).
   if (type != NIGORI)
     DCHECK(IsTypeWithClientGeneratedRoot(type));
   Entry same_type_root(trans, GET_TYPE_ROOT, type);
-  kernel_ = NULL;
+  kernel_ = nullptr;
   if (same_type_root.good()) {
     return;  // already have a type root for the given type
   }
 
   std::unique_ptr<EntryKernel> kernel(new EntryKernel());
 
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(type, &specifics);
   kernel->put(SPECIFICS, specifics);
 
@@ skipping 382 matching lines @@
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(BaseWriteTransaction* trans)
     : Entry(trans), base_write_transaction_(trans) {}
 
 void ModelNeutralMutableEntry::MarkDirty() {
   kernel_->mark_dirty(&dir()->kernel()->dirty_metahandles);
 }
 
 }  // namespace syncable
 
 }  // namespace syncer