[SyncFS] Use nullptr instead of NULL

chrome/browser/sync_file_system/local/sync_file_system_backend.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 "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 34 matching lines @@
                  content::Source<Profile>(profile_));
 }
 
 void SyncFileSystemBackend::ProfileHolder::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(CalledOnUIThread());
   DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
   DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
-  profile_ = NULL;
+  profile_ = nullptr;
   registrar_.RemoveAll();
 }
 
 Profile* SyncFileSystemBackend::ProfileHolder::GetProfile() {
   DCHECK(CalledOnUIThread());
   return profile_;
 }
 
 SyncFileSystemBackend::SyncFileSystemBackend(Profile* profile)
-    : context_(NULL),
+    : context_(nullptr),
       skip_initialize_syncfs_service_for_testing_(false) {
   DCHECK(CalledOnUIThread());
   if (profile)
     profile_holder_.reset(new ProfileHolder(profile));
 
   // Register the service name here to enable to crack an URL on SyncFileSystem
   // even if SyncFileSystemService has not started yet.
   RegisterSyncableFileSystem();
 }
 
 SyncFileSystemBackend::~SyncFileSystemBackend() {
   if (change_tracker_) {
     GetDelegate()->file_task_runner()->DeleteSoon(
         FROM_HERE, change_tracker_.release());
   }
 
   if (profile_holder_ && !CalledOnUIThread()) {
     BrowserThread::DeleteSoon(
         BrowserThread::UI, FROM_HERE, profile_holder_.release());
   }
 }
 
 // static
 SyncFileSystemBackend* SyncFileSystemBackend::CreateForTesting() {
   DCHECK(CalledOnUIThread());
-  SyncFileSystemBackend* backend = new SyncFileSystemBackend(NULL);
+  SyncFileSystemBackend* backend = new SyncFileSystemBackend(nullptr);
   backend->skip_initialize_syncfs_service_for_testing_ = true;
   return backend;
 }
 
 bool SyncFileSystemBackend::CanHandleType(storage::FileSystemType type) const {
   return type == storage::kFileSystemTypeSyncable ||
          type == storage::kFileSystemTypeSyncableForInternalSync;
 }
 
 void SyncFileSystemBackend::Initialize(storage::FileSystemContext* context) {
@@ skipping 33 matching lines @@
   InitializeSyncFileSystemService(url.origin(), initialize_callback);
 }
 
 storage::AsyncFileUtil* SyncFileSystemBackend::GetAsyncFileUtil(
     storage::FileSystemType type) {
   return GetDelegate()->file_util();
 }
 
 storage::WatcherManager* SyncFileSystemBackend::GetWatcherManager(
     storage::FileSystemType type) {
-  return NULL;
+  return nullptr;
 }
 
 storage::CopyOrMoveFileValidatorFactory*
 SyncFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
     storage::FileSystemType type,
     base::File::Error* error_code) {
   DCHECK(error_code);
   *error_code = base::File::FILE_OK;
-  return NULL;
+  return nullptr;
 }
 
 storage::FileSystemOperation* SyncFileSystemBackend::CreateFileSystemOperation(
     const storage::FileSystemURL& url,
     storage::FileSystemContext* context,
     base::File::Error* error_code) const {
   DCHECK(CanHandleType(url.type()));
   DCHECK(context);
   DCHECK(error_code);
 
   scoped_ptr<storage::FileSystemOperationContext> operation_context =
       GetDelegate()->CreateFileSystemOperationContext(url, context, error_code);
   if (!operation_context)
-    return NULL;
+    return nullptr;
 
   if (url.type() == storage::kFileSystemTypeSyncableForInternalSync) {
     return storage::FileSystemOperation::Create(
         url, context, operation_context.Pass());
   }
 
   return new SyncableFileSystemOperation(
       url, context, operation_context.Pass());
 }
 
@@ skipping 135 matching lines @@
                  SyncStatusCodeToFileError(status));
     return;
   }
 
   callback.Run(GetSyncableFileSystemRootURI(origin_url),
                GetFileSystemName(origin_url, type),
                base::File::FILE_OK);
 }
 
 }  // namespace sync_file_system