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

components/sync/syncable/directory.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/directory.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 83 matching lines @@
 }
 
 Directory::Kernel::~Kernel() {}
 
 Directory::Directory(
     DirectoryBackingStore* store,
     const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
     const base::Closure& report_unrecoverable_error_function,
     NigoriHandler* nigori_handler,
     Cryptographer* cryptographer)
-    : kernel_(NULL),
+    : kernel_(nullptr),
       store_(store),
       unrecoverable_error_handler_(unrecoverable_error_handler),
       report_unrecoverable_error_function_(report_unrecoverable_error_function),
       unrecoverable_error_set_(false),
       nigori_handler_(nigori_handler),
       cryptographer_(cryptographer),
       invariant_check_level_(VERIFY_CHANGES),
       weak_ptr_factory_(this) {}
 
 Directory::~Directory() {
@@ skipping 88 matching lines @@
 
 DeleteJournal* Directory::delete_journal() {
   DCHECK(delete_journal_.get());
   return delete_journal_.get();
 }
 
 void Directory::Close() {
   store_.reset();
   if (kernel_) {
     delete kernel_;
-    kernel_ = NULL;
+    kernel_ = nullptr;
   }
 }
 
 void Directory::OnUnrecoverableError(const BaseTransaction* trans,
                                      const tracked_objects::Location& location,
                                      const std::string& message) {
-  DCHECK(trans != NULL);
+  DCHECK(trans != nullptr);
   unrecoverable_error_set_ = true;
   unrecoverable_error_handler_.Call(
       FROM_HERE, &UnrecoverableErrorHandler::OnUnrecoverableError, location,
       message);
 }
 
 EntryKernel* Directory::GetEntryById(const Id& id) {
   ScopedKernelLock lock(this);
   return GetEntryById(lock, id);
 }
 
 EntryKernel* Directory::GetEntryById(const ScopedKernelLock& lock,
                                      const Id& id) {
   DCHECK(kernel_);
   // Find it in the in memory ID index.
   IdsMap::iterator id_found = kernel_->ids_map.find(id.value());
   if (id_found != kernel_->ids_map.end()) {
     return id_found->second;
   }
-  return NULL;
+  return nullptr;
 }
 
 EntryKernel* Directory::GetEntryByClientTag(const string& tag) {
   ScopedKernelLock lock(this);
   DCHECK(kernel_);
 
   TagsMap::iterator it = kernel_->client_tags_map.find(tag);
   if (it != kernel_->client_tags_map.end()) {
     return it->second;
   }
-  return NULL;
+  return nullptr;
 }
 
 EntryKernel* Directory::GetEntryByServerTag(const string& tag) {
   ScopedKernelLock lock(this);
   DCHECK(kernel_);
   TagsMap::iterator it = kernel_->server_tags_map.find(tag);
   if (it != kernel_->server_tags_map.end()) {
     return it->second;
   }
-  return NULL;
+  return nullptr;
 }
 
 EntryKernel* Directory::GetEntryByHandle(int64_t metahandle) {
   ScopedKernelLock lock(this);
   return GetEntryByHandle(lock, metahandle);
 }
 
 EntryKernel* Directory::GetEntryByHandle(const ScopedKernelLock& lock,
                                          int64_t metahandle) {
   // Look up in memory
   MetahandlesMap::iterator found = kernel_->metahandles_map.find(metahandle);
   if (found != kernel_->metahandles_map.end()) {
     // Found it in memory.  Easy.
     return found->second.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 bool Directory::GetChildHandlesById(BaseTransaction* trans,
                                     const Id& parent_id,
                                     Directory::Metahandles* result) {
   if (!SyncAssert(this == trans->directory(), FROM_HERE,
                   "Directories don't match", trans))
     return false;
   result->clear();
 
@@ skipping 51 matching lines @@
 }
 
 bool Directory::InsertEntry(BaseWriteTransaction* trans, EntryKernel* entry) {
   ScopedKernelLock lock(this);
   return InsertEntry(lock, trans, entry);
 }
 
 bool Directory::InsertEntry(const ScopedKernelLock& lock,
                             BaseWriteTransaction* trans,
                             EntryKernel* entry) {
-  if (!SyncAssert(NULL != entry, FROM_HERE, "Entry is null", trans))
+  if (!SyncAssert(nullptr != entry, FROM_HERE, "Entry is null", trans))
     return false;
 
   static const char error[] = "Entry already in memory index.";
 
   if (!SyncAssert(kernel_->metahandles_map
                       .insert(std::make_pair(entry->ref(META_HANDLE),
                                              base::WrapUnique(entry)))
                       .second,
                   FROM_HERE, error, trans)) {
     return false;
@@ skipping 22 matching lines @@
                   "Client tag should be empty", trans))
     return false;
 
   return true;
 }
 
 bool Directory::ReindexId(BaseWriteTransaction* trans,
                           EntryKernel* const entry,
                           const Id& new_id) {
   ScopedKernelLock lock(this);
-  if (NULL != GetEntryById(lock, new_id))
+  if (nullptr != GetEntryById(lock, new_id))
     return false;
 
   {
     // Update the indices that depend on the ID field.
     ScopedParentChildIndexUpdater updater_b(lock, entry,
                                             &kernel_->parent_child_index);
     size_t num_erased = kernel_->ids_map.erase(entry->ref(ID).value());
     DCHECK_EQ(1U, num_erased);
     entry->put(ID, new_id);
     kernel_->ids_map[entry->ref(ID).value()] = entry;
@@ skipping 70 matching lines @@
   IndexByAttachmentId::const_iterator index_iter =
       kernel_->index_by_attachment_id.find(attachment_id_proto.unique_id());
   if (index_iter == kernel_->index_by_attachment_id.end())
     return;
   const MetahandleSet& metahandle_set = index_iter->second;
   std::copy(metahandle_set.begin(), metahandle_set.end(),
             back_inserter(*result));
 }
 
 bool Directory::unrecoverable_error_set(const BaseTransaction* trans) const {
-  DCHECK(trans != NULL);
+  DCHECK(trans != nullptr);
   return unrecoverable_error_set_;
 }
 
 void Directory::ClearDirtyMetahandles(const ScopedKernelLock& lock) {
   kernel_->transaction_mutex.AssertAcquired();
   kernel_->dirty_metahandles.clear();
 }
 
 bool Directory::SafeToPurgeFromMemory(WriteTransaction* trans,
                                       const EntryKernel* const entry) const {
@@ skipping 35 matching lines @@
     if (!entry)
       continue;
     // Skip over false positives; it happens relatively infrequently.
     if (!entry->is_dirty())
       continue;
     snapshot->dirty_metas.insert(snapshot->dirty_metas.end(),
                                  base::MakeUnique<EntryKernel>(*entry));
     DCHECK_EQ(1U, kernel_->dirty_metahandles.count(*i));
     // We don't bother removing from the index here as we blow the entire thing
     // in a moment, and it unnecessarily complicates iteration.
-    entry->clear_dirty(NULL);
+    entry->clear_dirty(nullptr);
   }
   ClearDirtyMetahandles(lock);
 
   // Set purged handles.
   DCHECK(snapshot->metahandles_to_purge.empty());
   snapshot->metahandles_to_purge.swap(kernel_->metahandles_to_purge);
 
   // Fill kernel_info_status and kernel_info.
   snapshot->kernel_info = kernel_->persisted_info;
   snapshot->kernel_info_status = kernel_->info_status;
@@ skipping 28 matching lines @@
 
   // Need a write transaction as we are about to permanently purge entries.
   WriteTransaction trans(FROM_HERE, VACUUM_AFTER_SAVE, this);
   ScopedKernelLock lock(this);
   // Now drop everything we can out of memory.
   for (auto i = snapshot.dirty_metas.begin(); i != snapshot.dirty_metas.end();
        ++i) {
     MetahandlesMap::iterator found =
         kernel_->metahandles_map.find((*i)->ref(META_HANDLE));
     EntryKernel* entry =
-        (found == kernel_->metahandles_map.end() ? NULL : found->second.get());
+        (found == kernel_->metahandles_map.end() ? nullptr
+                                                 : found->second.get());
     if (entry && SafeToPurgeFromMemory(&trans, entry)) {
       // We now drop deleted metahandles that are up to date on both the client
       // and the server.
       std::unique_ptr<EntryKernel> unique_entry = std::move(found->second);
 
       size_t num_erased = 0;
       num_erased = kernel_->metahandles_map.erase(entry->ref(META_HANDLE));
       DCHECK_EQ(1u, num_erased);
       num_erased = kernel_->ids_map.erase(entry->ref(ID).value());
       DCHECK_EQ(1u, num_erased);
@@ skipping 705 matching lines @@
   return metahandle;
 }
 
 // Generates next client ID based on a randomly generated GUID.
 Id Directory::NextId() {
   return Id::CreateFromClientString(base::GenerateGUID());
 }
 
 bool Directory::HasChildren(BaseTransaction* trans, const Id& id) {
   ScopedKernelLock lock(this);
-  return kernel_->parent_child_index.GetChildren(id) != NULL;
+  return kernel_->parent_child_index.GetChildren(id) != nullptr;
 }
 
 Id Directory::GetFirstChildId(BaseTransaction* trans,
                               const EntryKernel* parent) {
   DCHECK(parent);
   DCHECK(parent->ref(IS_DIR));
 
   ScopedKernelLock lock(this);
   const OrderedChildSet* children =
       kernel_->parent_child_index.GetChildren(parent->ref(ID));
@@ skipping 53 matching lines @@
   ScopedKernelLock lock(this);
   ScopedParentChildIndexUpdater updater(lock, e, &kernel_->parent_child_index);
 
   // Note: The ScopedParentChildIndexUpdater will update this set for us as we
   // leave this function.
   const OrderedChildSet* siblings =
       kernel_->parent_child_index.GetChildren(e->ref(PARENT_ID));
 
   if (!siblings) {
     // This parent currently has no other children.
-    DCHECK(predecessor == NULL);
+    DCHECK(predecessor == nullptr);
     UniquePosition pos = UniquePosition::InitialPosition(suffix);
     e->put(UNIQUE_POSITION, pos);
     return;
   }
 
-  if (predecessor == NULL) {
+  if (predecessor == nullptr) {
     // We have at least one sibling, and we're inserting to the left of them.
     UniquePosition successor_pos = (*siblings->begin())->ref(UNIQUE_POSITION);
 
     UniquePosition pos;
     if (!successor_pos.IsValid()) {
       // If all our successors are of non-positionable types, just create an
       // initial position.  We arbitrarily choose to sort invalid positions to
       // the right of the valid positions.
       //
       // We really shouldn't need to support this.  See TODO above.
@@ skipping 123 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer