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

components/sync/driver/glue/sync_backend_registrar.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/driver/glue/sync_backend_registrar.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <utility>
 
@@ skipping 189 matching lines @@
 
   DCHECK(ui_thread_->BelongsToCurrentThread() || IsControlType(type));
   base::AutoLock lock(lock_);
 
   routing_info_.erase(type);
   ignore_result(processors_.erase(type));
   DCHECK(!GetProcessorUnsafe(type));
 }
 
 bool SyncBackendRegistrar::IsTypeActivatedForTest(ModelType type) const {
-  return GetProcessor(type) != NULL;
+  return GetProcessor(type) != nullptr;
 }
 
 void SyncBackendRegistrar::OnChangesApplied(
     ModelType model_type,
     int64_t model_version,
     const BaseTransaction* trans,
     const ImmutableChangeRecordList& changes) {
   ChangeProcessor* processor = GetProcessor(model_type);
   if (!processor)
     return;
@@ skipping 25 matching lines @@
 void SyncBackendRegistrar::GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
   base::AutoLock lock(lock_);
   ModelSafeRoutingInfo copy(routing_info_);
   out->swap(copy);
 }
 
 ChangeProcessor* SyncBackendRegistrar::GetProcessor(ModelType type) const {
   base::AutoLock lock(lock_);
   ChangeProcessor* processor = GetProcessorUnsafe(type);
   if (!processor)
-    return NULL;
+    return nullptr;
 
   // We can only check if |processor| exists, as otherwise the type is
   // mapped to GROUP_PASSIVE.
   CHECK(IsCurrentThreadSafeForModel(type));
   return processor;
 }
 
 ChangeProcessor* SyncBackendRegistrar::GetProcessorUnsafe(
     ModelType type) const {
   lock_.AssertAcquired();
   std::map<ModelType, ChangeProcessor*>::const_iterator it =
       processors_.find(type);
 
   // Until model association happens for a datatype, it will not
   // appear in the processors list.  During this time, it is OK to
   // drop changes on the floor (since model association has not
   // happened yet).  When the data type is activated, model
   // association takes place then the change processor is added to the
   // |processors_| list.
   if (it == processors_.end())
-    return NULL;
+    return nullptr;
 
   return it->second;
 }
 
 bool SyncBackendRegistrar::IsCurrentThreadSafeForModel(
     ModelType model_type) const {
   lock_.AssertAcquired();
   return IsOnThreadForGroup(model_type,
                             GetGroupForModelType(model_type, routing_info_));
 }
@@ skipping 86 matching lines @@
 base::Thread* SyncBackendRegistrar::sync_thread() {
   return sync_thread_.get();
 }
 
 ModelSafeGroup SyncBackendRegistrar::GetInitialGroupForType(
     ModelType type) const {
   return non_blocking_types_.Has(type) ? GROUP_NON_BLOCKING : GROUP_PASSIVE;
 }
 
 }  // namespace syncer