replace NULL->nullptr in src/remoting.

remoting/host/win/wts_session_process_delegate.cc

 // Copyright (c) 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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/wts_session_process_delegate.h"
 
 #include "base/bind.h"
@@ skipping 131 matching lines @@
 };
 
 WtsSessionProcessDelegate::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_ptr<base::CommandLine> target_command,
     bool launch_elevated,
     const std::string& channel_security)
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
       channel_security_(channel_security),
-      event_handler_(NULL),
-      get_named_pipe_client_pid_(NULL),
+      event_handler_(nullptr),
+      get_named_pipe_client_pid_(nullptr),
       launch_elevated_(launch_elevated),
       launch_pending_(false),
       target_command_(target_command.Pass()) {
 }
 
 bool WtsSessionProcessDelegate::Core::Initialize(uint32 session_id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Windows XP does not support elevation.
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     launch_elevated_ = false;
 
   if (launch_elevated_) {
     // GetNamedPipeClientProcessId() is available starting from Vista.
     HMODULE kernel32 = ::GetModuleHandle(L"kernel32.dll");
-    CHECK(kernel32 != NULL);
+    CHECK(kernel32 != nullptr);
 
     get_named_pipe_client_pid_ =
         reinterpret_cast<GetNamedPipeClientProcessIdFn>(
             GetProcAddress(kernel32, "GetNamedPipeClientProcessId"));
-    CHECK(get_named_pipe_client_pid_ != NULL);
+    CHECK(get_named_pipe_client_pid_ != nullptr);
 
     ScopedHandle job;
-    job.Set(CreateJobObject(NULL, NULL));
+    job.Set(CreateJobObject(nullptr, nullptr));
     if (!job.IsValid()) {
       PLOG(ERROR) << "Failed to create a job object";
       return false;
     }
 
     // Limit the number of active processes in the job to two (the helper
     // process performing elevation and the worker process itself) and make sure
     // that all processes will be killed once the job object is destroyed.
     JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
     memset(&info, 0, sizeof(info));
@@ skipping 60 matching lines @@
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   channel_.reset();
   pipe_.Close();
 }
 
 void WtsSessionProcessDelegate::Core::KillProcess() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   channel_.reset();
-  event_handler_ = NULL;
+  event_handler_ = nullptr;
   launch_pending_ = false;
   pipe_.Close();
 
   if (launch_elevated_) {
     if (job_.IsValid())
       TerminateJobObject(job_.Get(), CONTROL_C_EXIT);
   } else {
     if (worker_process_.IsValid())
       TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
   }
@@ skipping 119 matching lines @@
   // Pass the name of the IPC channel to use.
   command_line.AppendSwitchNative(kDaemonPipeSwitchName,
                                   base::UTF8ToWide(channel_name));
 
   // Try to launch the process.
   ScopedHandle worker_process;
   ScopedHandle worker_thread;
   if (!LaunchProcessWithToken(command_line.GetProgram(),
                               command_line.GetCommandLineString(),
                               session_token_.Get(),
-                              NULL,
-                              NULL,
+                              nullptr,
+                              nullptr,
                               false,
                               CREATE_SUSPENDED | CREATE_BREAKAWAY_FROM_JOB,
                               base::UTF8ToUTF16(kDefaultDesktopName).c_str(),
                               &worker_process,
                               &worker_thread)) {
     ReportFatalError();
     return;
   }
 
   if (launch_elevated_) {
@@ skipping 79 matching lines @@
   }
 }
 
 void WtsSessionProcessDelegate::Core::ReportFatalError() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   channel_.reset();
   pipe_.Close();
 
   WorkerProcessLauncher* event_handler = event_handler_;
-  event_handler_ = NULL;
+  event_handler_ = nullptr;
   event_handler->OnFatalError();
 }
 
 void WtsSessionProcessDelegate::Core::ReportProcessLaunched(
     base::win::ScopedHandle worker_process) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!worker_process_.IsValid());
 
   worker_process_ = worker_process.Pass();
 
@@ skipping 48 matching lines @@
 
 void WtsSessionProcessDelegate::CloseChannel() {
   core_->CloseChannel();
 }
 
 void WtsSessionProcessDelegate::KillProcess() {
   core_->KillProcess();
 }
 
 }  // namespace remoting