[SyncFS] Use nullptr instead of NULL

chrome/browser/sync_file_system/local/local_file_sync_context_unittest.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/local_file_sync_context.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 64 matching lines @@
   virtual void TearDown() OVERRIDE {
     RevokeSyncableFileSystem();
   }
 
   void StartPrepareForSync(FileSystemContext* file_system_context,
                            const FileSystemURL& url,
                            LocalFileSyncContext::SyncMode sync_mode,
                            SyncFileMetadata* metadata,
                            FileChangeList* changes,
                            storage::ScopedFile* snapshot) {
-    ASSERT_TRUE(changes != NULL);
+    ASSERT_TRUE(changes != nullptr);
     ASSERT_FALSE(has_inflight_prepare_for_sync_);
     status_ = SYNC_STATUS_UNKNOWN;
     has_inflight_prepare_for_sync_ = true;
     sync_context_->PrepareForSync(
         file_system_context,
         url,
         sync_mode,
         base::Bind(&LocalFileSyncContextTest::DidPrepareForSync,
                    base::Unretained(this), metadata, changes, snapshot));
   }
@@ skipping 46 matching lines @@
                                    SyncFileType expected_file_type) {
     SCOPED_TRACE(testing::Message() << "ApplyChange for " <<
                  url.DebugString());
 
     // First we should call PrepareForSync to disable writing.
     SyncFileMetadata metadata;
     FileChangeList changes;
     EXPECT_EQ(SYNC_STATUS_OK,
               PrepareForSync(file_system_context, url,
                              LocalFileSyncContext::SYNC_EXCLUSIVE,
-                             &metadata, &changes, NULL));
+                             &metadata, &changes, nullptr));
     EXPECT_EQ(expected_file_type, metadata.file_type);
 
     status_ = SYNC_STATUS_UNKNOWN;
     sync_context_->ApplyRemoteChange(
         file_system_context, change, local_path, url,
         base::Bind(&LocalFileSyncContextTest::DidApplyRemoteChange,
                    base::Unretained(this),
                    make_scoped_refptr(file_system_context), url));
     base::MessageLoop::current()->Run();
     return status_;
   }
 
   void DidApplyRemoteChange(FileSystemContext* file_system_context,
                             const FileSystemURL& url,
                             SyncStatusCode status) {
     status_ = status;
     sync_context_->FinalizeExclusiveSync(
         file_system_context, url,
         status == SYNC_STATUS_OK /* clear_local_changes */,
         base::MessageLoop::QuitClosure());
   }
 
   void StartModifyFileOnIOThread(CannedSyncableFileSystem* file_system,
                                  const FileSystemURL& url) {
-    ASSERT_TRUE(file_system != NULL);
+    ASSERT_TRUE(file_system != nullptr);
     if (!io_task_runner_->RunsTasksOnCurrentThread()) {
       async_modify_finished_ = false;
       ASSERT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
       io_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&LocalFileSyncContextTest::StartModifyFileOnIOThread,
                      base::Unretained(this), file_system, url));
       return;
     }
     ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 54 matching lines @@
                   sync_context_.get()));
     ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
     const FileSystemURL kFile(file_system.URL("file"));
     EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
 
     SyncFileMetadata metadata;
     FileChangeList changes;
     EXPECT_EQ(SYNC_STATUS_OK,
               PrepareForSync(file_system.file_system_context(), kFile,
-                             sync_mode, &metadata, &changes, NULL));
+                             sync_mode, &metadata, &changes, nullptr));
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
     // We should see the same set of changes.
     file_system.GetChangesForURLInTracker(kFile, &changes);
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
     SimulateFinishSync(file_system.file_system_context(), kFile,
                        simulate_sync_finish_status, sync_mode);
 
     file_system.GetChangesForURLInTracker(kFile, &changes);
     if (simulate_sync_finish_status == SYNC_STATUS_OK) {
       // The change's cleared.
       EXPECT_TRUE(changes.empty());
     } else {
       EXPECT_EQ(1U, changes.size());
       EXPECT_TRUE(changes.list().back().IsFile());
       EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
     }
 
     sync_context_->ShutdownOnUIThread();
-    sync_context_ = NULL;
+    sync_context_ = nullptr;
 
     file_system.TearDown();
   }
 
   void PrepareForSync_WriteDuringSync(
       LocalFileSyncContext::SyncMode sync_mode) {
     CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                          in_memory_env_.get(),
                                          io_task_runner_.get(),
                                          file_task_runner_.get());
@@ skipping 44 matching lines @@
     EXPECT_EQ(base::File::FILE_OK, WaitUntilModifyFileIsDone());
 
     // Sync succeeded, but the other change that was made during or
     // after sync is recorded.
     file_system.GetChangesForURLInTracker(kFile, &changes);
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
     sync_context_->ShutdownOnUIThread();
-    sync_context_ = NULL;
+    sync_context_ = nullptr;
 
     file_system.TearDown();
   }
 
   base::ScopedTempDir dir_;
   scoped_ptr<leveldb::Env> in_memory_env_;
 
   // These need to remain until the very end.
   content::TestBrowserThreadBundle thread_bundle_;
 
@@ skipping 27 matching lines @@
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), in_memory_env_.get(),
       ui_task_runner_.get(), io_task_runner_.get());
 
   // Initializes file_system using |sync_context_|.
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   // Make sure everything's set up for file_system to be able to handle
   // syncable file system operations.
-  EXPECT_TRUE(file_system.backend()->sync_context() != NULL);
-  EXPECT_TRUE(file_system.backend()->change_tracker() != NULL);
+  EXPECT_TRUE(file_system.backend()->sync_context() != nullptr);
+  EXPECT_TRUE(file_system.backend()->change_tracker() != nullptr);
   EXPECT_EQ(sync_context_.get(), file_system.backend()->sync_context());
 
   // Calling MaybeInitialize for the same context multiple times must be ok.
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   EXPECT_EQ(sync_context_.get(), file_system.backend()->sync_context());
 
   // Opens the file_system, perform some operation and see if the change tracker
   // correctly captures the change.
   EXPECT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
@@ skipping 66 matching lines @@
   urls.clear();
   file_system2.GetChangedURLsInTracker(&urls);
   ASSERT_EQ(1U, urls.size());
   EXPECT_TRUE(ContainsKey(urls, kURL2));
 
   SyncFileMetadata metadata;
   FileChangeList changes;
   EXPECT_EQ(SYNC_STATUS_OK,
             PrepareForSync(file_system1.file_system_context(), kURL1,
                            LocalFileSyncContext::SYNC_EXCLUSIVE,
-                           &metadata, &changes, NULL));
+                           &metadata, &changes, nullptr));
   EXPECT_EQ(1U, changes.size());
   EXPECT_TRUE(changes.list().back().IsFile());
   EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
   EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
   EXPECT_EQ(0, metadata.size);
 
   changes.clear();
   EXPECT_EQ(SYNC_STATUS_OK,
             PrepareForSync(file_system2.file_system_context(), kURL2,
                            LocalFileSyncContext::SYNC_EXCLUSIVE,
-                           &metadata, &changes, NULL));
+                           &metadata, &changes, nullptr));
   EXPECT_EQ(1U, changes.size());
   EXPECT_FALSE(changes.list().back().IsFile());
   EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
   EXPECT_EQ(SYNC_FILE_TYPE_DIRECTORY, metadata.file_type);
   EXPECT_EQ(0, metadata.size);
 
   sync_context_->ShutdownOnUIThread();
-  sync_context_ = NULL;
+  sync_context_ = nullptr;
 
   file_system1.TearDown();
   file_system2.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, PrepareSync_SyncSuccess_Exclusive) {
   PrepareForSync_Basic(LocalFileSyncContext::SYNC_EXCLUSIVE,
                        SYNC_STATUS_OK);
 }
 
@@ skipping 46 matching lines @@
   // Kick file write on IO thread.
   StartModifyFileOnIOThread(&file_system, kURL1);
 
   // Until the operation finishes PrepareForSync should return BUSY error.
   SyncFileMetadata metadata;
   metadata.file_type = SYNC_FILE_TYPE_UNKNOWN;
   FileChangeList changes;
   EXPECT_EQ(SYNC_STATUS_FILE_BUSY,
             PrepareForSync(file_system.file_system_context(), kURL1,
                            LocalFileSyncContext::SYNC_EXCLUSIVE,
-                           &metadata, &changes, NULL));
+                           &metadata, &changes, nullptr));
   EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
 
   // Register PrepareForSync method to be invoked when kURL1 becomes
   // syncable. (Actually this may be done after all operations are done
   // on IO thread in this test.)
   metadata.file_type = SYNC_FILE_TYPE_UNKNOWN;
   changes.clear();
   sync_context_->RegisterURLForWaitingSync(
       kURL1, GetPrepareForSyncClosure(file_system.file_system_context(), kURL1,
                                       LocalFileSyncContext::SYNC_EXCLUSIVE,
-                                      &metadata, &changes, NULL));
+                                      &metadata, &changes, nullptr));
 
   // Wait for the completion.
   EXPECT_EQ(base::File::FILE_OK, WaitUntilModifyFileIsDone());
 
   // The PrepareForSync must have been started; wait until DidPrepareForSync
   // is done.
   base::MessageLoop::current()->Run();
   ASSERT_FALSE(has_inflight_prepare_for_sync_);
 
   // Now PrepareForSync should have run and returned OK.
   EXPECT_EQ(SYNC_STATUS_OK, status_);
   EXPECT_EQ(1U, changes.size());
   EXPECT_TRUE(changes.list().back().IsFile());
   EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
   EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
   EXPECT_EQ(1, metadata.size);
 
   sync_context_->ShutdownOnUIThread();
-  sync_context_ = NULL;
+  sync_context_ = nullptr;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp(CannedSyncableFileSystem::QUOTA_ENABLED);
 
@@ skipping 67 matching lines @@
   urls.clear();
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
   // The quota usage data must have reflected the deletion.
   EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_EQ(new_usage, initial_usage);
 
   sync_context_->ShutdownOnUIThread();
-  sync_context_ = NULL;
+  sync_context_ = nullptr;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion_ForRoot) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp(CannedSyncableFileSystem::QUOTA_ENABLED);
 
@@ skipping 46 matching lines @@
   FileSystemURLSet urls;
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
   // The quota usage data must have reflected the deletion.
   EXPECT_EQ(storage::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_EQ(new_usage, initial_usage);
 
   sync_context_->ShutdownOnUIThread();
-  sync_context_ = NULL;
+  sync_context_ = nullptr;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        in_memory_env_.get(),
                                        io_task_runner_.get(),
@@ skipping 190 matching lines @@
 
   // Make sure kDir and kFile are created by ApplyRemoteChange.
   EXPECT_EQ(base::File::FILE_OK, file_system.FileExists(kFile));
   EXPECT_EQ(base::File::FILE_OK, file_system.DirectoryExists(kDir));
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 }  // namespace sync_file_system