replace NULL->nullptr in src/remoting.

remoting/host/win/launch_process_with_token.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.
 
 #include "remoting/host/win/launch_process_with_token.h"
 
 #include <windows.h>
 #include <winternl.h>
 
 #include <limits>
@@ skipping 23 matching lines @@
     static_cast<WINSTATIONINFOCLASS>(0x21);
 
 const int kPipeBusyWaitTimeoutMs = 2000;
 const int kPipeConnectMaxAttempts = 3;
 
 // Terminates the process and closes process and thread handles in
 // |process_information| structure.
 void CloseHandlesAndTerminateProcess(PROCESS_INFORMATION* process_information) {
   if (process_information->hThread) {
     CloseHandle(process_information->hThread);
-    process_information->hThread = NULL;
+    process_information->hThread = nullptr;
   }
 
   if (process_information->hProcess) {
     TerminateProcess(process_information->hProcess, CONTROL_C_EXIT);
     CloseHandle(process_information->hProcess);
-    process_information->hProcess = NULL;
+    process_information->hProcess = nullptr;
   }
 }
 
 // Connects to the executor server corresponding to |session_id|.
 bool ConnectToExecutionServer(uint32 session_id,
                               base::win::ScopedHandle* pipe_out) {
   base::string16 pipe_name;
 
   // Use winsta!WinStationQueryInformationW() to determine the process creation
   // pipe name for the session.
@@ skipping 23 matching lines @@
     pipe_name = base::UTF8ToUTF16(
         base::StringPrintf(kCreateProcessDefaultPipeNameFormat, session_id));
   }
 
   // Try to connect to the named pipe.
   base::win::ScopedHandle pipe;
   for (int i = 0; i < kPipeConnectMaxAttempts; ++i) {
     pipe.Set(CreateFile(pipe_name.c_str(),
                         GENERIC_READ | GENERIC_WRITE,
                         0,
-                        NULL,
+                        nullptr,
                         OPEN_EXISTING,
                         0,
-                        NULL));
+                        nullptr));
     if (pipe.IsValid()) {
       break;
     }
 
     // Cannot continue retrying if error is something other than
     // ERROR_PIPE_BUSY.
     if (GetLastError() != ERROR_PIPE_BUSY) {
       break;
     }
 
@@ skipping 19 matching lines @@
   if (!OpenProcessToken(GetCurrentProcess(),
                         TOKEN_DUPLICATE | desired_access,
                         &temp_handle)) {
     PLOG(ERROR) << "Failed to open process token";
     return false;
   }
   ScopedHandle process_token(temp_handle);
 
   if (!DuplicateTokenEx(process_token.Get(),
                         desired_access,
-                        NULL,
+                        nullptr,
                         SecurityImpersonation,
                         TokenPrimary,
                         &temp_handle)) {
     PLOG(ERROR) << "Failed to duplicate the process token";
     return false;
   }
 
   token_out->Set(temp_handle);
   return true;
 }
 
 // Creates a copy of the current process with SE_TCB_NAME privilege enabled.
 bool CreatePrivilegedToken(ScopedHandle* token_out) {
   ScopedHandle privileged_token;
   DWORD desired_access = TOKEN_ADJUST_PRIVILEGES | TOKEN_IMPERSONATE |
                          TOKEN_DUPLICATE | TOKEN_QUERY;
   if (!CopyProcessToken(desired_access, &privileged_token)) {
     return false;
   }
 
   // Get the LUID for the SE_TCB_NAME privilege.
   TOKEN_PRIVILEGES state;
   state.PrivilegeCount = 1;
   state.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
-  if (!LookupPrivilegeValue(NULL, SE_TCB_NAME, &state.Privileges[0].Luid)) {
+  if (!LookupPrivilegeValue(nullptr, SE_TCB_NAME, &state.Privileges[0].Luid)) {
     PLOG(ERROR) << "Failed to lookup the LUID for the SE_TCB_NAME privilege";
     return false;
   }
 
   // Enable the SE_TCB_NAME privilege.
-  if (!AdjustTokenPrivileges(privileged_token.Get(), FALSE, &state, 0, NULL,
+  if (!AdjustTokenPrivileges(privileged_token.Get(), FALSE, &state, 0, nullptr,
                              0)) {
     PLOG(ERROR) << "Failed to enable SE_TCB_NAME privilege in a token";
     return false;
   }
 
   *token_out = privileged_token.Pass();
   return true;
 }
 
 // Fills the process and thread handles in the passed |process_information|
@@ skipping 77 matching lines @@
     PROCESS_INFORMATION* process_information_out) {
   struct CreateProcessResponse {
     DWORD size;
     BOOL success;
     DWORD last_error;
     PROCESS_INFORMATION process_information;
   };
 
   DWORD bytes;
   CreateProcessResponse response;
-  if (!ReadFile(pipe, &response, sizeof(response), &bytes, NULL)) {
+  if (!ReadFile(pipe, &response, sizeof(response), &bytes, nullptr)) {
     PLOG(ERROR) << "Failed to receive CreateProcessAsUser response";
     return false;
   }
 
   // The server sends the data in one chunk so if we didn't received a complete
   // answer something bad happend and there is no point in retrying.
   if (bytes != sizeof(response)) {
     SetLastError(ERROR_RECEIVE_PARTIAL);
     return false;
   }
@@ skipping 34 matching lines @@
     LPWSTR current_directory;
     STARTUPINFOW startup_info;
     PROCESS_INFORMATION process_information;
   };
 
   base::string16 desktop;
   if (desktop_name)
     desktop = desktop_name;
 
   // Allocate a large enough buffer to hold the CreateProcessRequest structure
-  // and three NULL-terminated string parameters.
+  // and three nullptr-terminated string parameters.
   size_t size = sizeof(CreateProcessRequest) + sizeof(wchar_t) *
       (application_name.size() + command_line.size() + desktop.size() + 3);
   scoped_ptr<char[]> buffer(new char[size]);
   memset(buffer.get(), 0, size);
 
   // Marshal the input parameters.
   CreateProcessRequest* request =
       reinterpret_cast<CreateProcessRequest*>(buffer.get());
   request->size = size;
   request->process_id = GetCurrentProcessId();
@@ skipping 18 matching lines @@
   buffer_offset += (command_line.size() + 1) * sizeof(wchar_t);
 
   request->startup_info.lpDesktop =
       reinterpret_cast<LPWSTR>(buffer_offset);
   std::copy(desktop.begin(),
             desktop.end(),
             reinterpret_cast<wchar_t*>(buffer.get() + buffer_offset));
 
   // Pass the request to create a process in the target session.
   DWORD bytes;
-  if (!WriteFile(pipe, buffer.get(), size, &bytes, NULL)) {
+  if (!WriteFile(pipe, buffer.get(), size, &bytes, nullptr)) {
     PLOG(ERROR) << "Failed to send CreateProcessAsUser request";
     return false;
   }
 
   return true;
 }
 
 // Requests the execution server to create a process in the specified session
 // using the default (i.e. Winlogon) token. This routine relies on undocumented
 // OS functionality and will likely not work on anything but XP or W2K3.
@@ skipping 95 matching lines @@
     startup_info.lpDesktop = const_cast<base::char16*>(desktop_name);
 
   PROCESS_INFORMATION temp_process_info = {};
   BOOL result = CreateProcessAsUser(user_token,
                                     application_name.c_str(),
                                     const_cast<LPWSTR>(command_line.c_str()),
                                     process_attributes,
                                     thread_attributes,
                                     inherit_handles,
                                     creation_flags,
-                                    NULL,
-                                    NULL,
+                                    nullptr,
+                                    nullptr,
                                     &startup_info,
                                     &temp_process_info);
 
   // CreateProcessAsUser will fail on XP and W2K3 with ERROR_PIPE_NOT_CONNECTED
   // if the user hasn't logged to the target session yet. In such a case
   // we try to talk to the execution server directly emulating what
   // the undocumented and not-exported advapi32!CreateRemoteSessionProcessW()
   // function does. The created process will run under Winlogon'a token instead
   // of |user_token|. Since Winlogon runs as SYSTEM, this suits our needs.
   if (!result &&
@@ skipping 27 matching lines @@
 
   base::win::ScopedProcessInformation process_info(temp_process_info);
 
   CHECK(process_info.IsValid());
   process_out->Set(process_info.TakeProcessHandle());
   thread_out->Set(process_info.TakeThreadHandle());
   return true;
 }
 
 }  // namespace remoting