replace NULL->nullptr in src/remoting.

remoting/host/win/unprivileged_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/unprivileged_process_delegate.h"
 
@@ skipping 58 matching lines @@
 // full access to the threads. It gives READ_CONTROL, SYNCHRONIZE,
 // THREAD_QUERY_INFORMATION and THREAD_TERMINATE rights to the built-in
 // administrators group.
 const char kWorkerThreadSd[] = "O:SYG:SYD:(A;;GA;;;SY)(A;;0x120801;;;BA)";
 
 // Creates a token with limited access that will be used to run the worker
 // process.
 bool CreateRestrictedToken(ScopedHandle* token_out) {
   // Create a token representing LocalService account.
   HANDLE temp_handle;
-  if (!LogonUser(L"LocalService", L"NT AUTHORITY", NULL, LOGON32_LOGON_SERVICE,
-                 LOGON32_PROVIDER_DEFAULT, &temp_handle)) {
+  if (!LogonUser(L"LocalService", L"NT AUTHORITY", nullptr,
+                 LOGON32_LOGON_SERVICE, LOGON32_PROVIDER_DEFAULT,
+                 &temp_handle)) {
     return false;
   }
   ScopedHandle token(temp_handle);
 
   sandbox::RestrictedToken restricted_token;
   if (restricted_token.Init(token.Get()) != ERROR_SUCCESS)
     return false;
 
   // Remove all privileges in the token.
-  if (restricted_token.DeleteAllPrivileges(NULL) != ERROR_SUCCESS)
+  if (restricted_token.DeleteAllPrivileges(nullptr) != ERROR_SUCCESS)
     return false;
 
   // Set low integrity level if supported by the OS.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     if (restricted_token.SetIntegrityLevel(sandbox::INTEGRITY_LEVEL_LOW)
         != ERROR_SUCCESS) {
       return false;
     }
   }
 
@@ skipping 84 matching lines @@
       DESKTOP_JOURNALPLAYBACK | DESKTOP_ENUMERATE | DESKTOP_WRITEOBJECTS |
       DESKTOP_SWITCHDESKTOP | DELETE | READ_CONTROL | WRITE_DAC | WRITE_OWNER;
 
   security_attributes.nLength = sizeof(security_attributes);
   security_attributes.lpSecurityDescriptor = desktop_sd.get();
   security_attributes.bInheritHandle = TRUE;
 
   // The default desktop of the interactive window station is called "Default".
   // Name the created desktop the same way in case any code relies on that.
   // The desktop name should not make any difference though.
-  handles.SetDesktop(CreateDesktop(L"Default", NULL, NULL, 0, desired_access,
-                                   &security_attributes));
+  handles.SetDesktop(CreateDesktop(L"Default", nullptr, nullptr, 0,
+                                   desired_access, &security_attributes));
 
   // Switch back to the original window station.
   if (!SetProcessWindowStation(current_window_station)) {
     PLOG(ERROR) << "SetProcessWindowStation() failed";
     return false;
   }
 
   if (!handles.desktop()) {
     PLOG(ERROR) << "CreateDesktop() failed";
     return false;
   }
 
   handles.Swap(*handles_out);
   return true;
 }
 
 }  // namespace
 
 UnprivilegedProcessDelegate::UnprivilegedProcessDelegate(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_ptr<base::CommandLine> target_command)
     : io_task_runner_(io_task_runner),
-      event_handler_(NULL),
+      event_handler_(nullptr),
       target_command_(target_command.Pass()) {
 }
 
 UnprivilegedProcessDelegate::~UnprivilegedProcessDelegate() {
   DCHECK(CalledOnValidThread());
   DCHECK(!channel_);
   DCHECK(!worker_process_.IsValid());
 }
 
 void UnprivilegedProcessDelegate::LaunchProcess(
@@ skipping 74 matching lines @@
     // Try to launch the worker process. The launched process inherits
     // the window station, desktop and pipe handles, created above.
     ScopedHandle worker_thread;
     if (!LaunchProcessWithToken(command_line.GetProgram(),
                                 command_line.GetCommandLineString(),
                                 token.Get(),
                                 &process_attributes,
                                 &thread_attributes,
                                 true,
                                 0,
-                                NULL,
+                                nullptr,
                                 &worker_process,
                                 &worker_thread)) {
       ReportFatalError();
       return;
     }
   }
 
   channel_ = server.Pass();
   ReportProcessLaunched(worker_process.Pass());
 }
@@ skipping 11 matching lines @@
 void UnprivilegedProcessDelegate::CloseChannel() {
   DCHECK(CalledOnValidThread());
 
   channel_.reset();
 }
 
 void UnprivilegedProcessDelegate::KillProcess() {
   DCHECK(CalledOnValidThread());
 
   channel_.reset();
-  event_handler_ = NULL;
+  event_handler_ = nullptr;
 
   if (worker_process_.IsValid()) {
     TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
     worker_process_.Close();
   }
 }
 
 bool UnprivilegedProcessDelegate::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
@@ skipping 21 matching lines @@
 
   event_handler_->OnChannelError();
 }
 
 void UnprivilegedProcessDelegate::ReportFatalError() {
   DCHECK(CalledOnValidThread());
 
   channel_.reset();
 
   WorkerProcessLauncher* event_handler = event_handler_;
-  event_handler_ = NULL;
+  event_handler_ = nullptr;
   event_handler->OnFatalError();
 }
 
 void UnprivilegedProcessDelegate::ReportProcessLaunched(
     base::win::ScopedHandle worker_process) {
   DCHECK(CalledOnValidThread());
   DCHECK(!worker_process_.IsValid());
 
   worker_process_ = worker_process.Pass();
 
@@ skipping 12 matching lines @@
     PLOG(ERROR) << "Failed to duplicate a handle";
     ReportFatalError();
     return;
   }
   ScopedHandle limited_handle(temp_handle);
 
   event_handler_->OnProcessLaunched(limited_handle.Pass());
 }
 
 }  // namespace remoting