Set current directory when launching Native Messaging processes.

base/process/launch_win.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 "base/process/launch.h"
 
 #include <fcntl.h>
 #include <io.h>
 #include <shellapi.h>
 #include <windows.h>
@@ skipping 31 matching lines @@
 // process.  It's value is obviously not that unique, and it's
 // surprising to me that the task manager uses this value, but it
 // seems to be common practice on Windows to test for it as an
 // indication that the task manager has killed something if the
 // process goes away.
 const DWORD kProcessKilledExitCode = 1;
 
 bool GetAppOutputInternal(const StringPiece16& cl,
                           bool include_stderr,
                           std::string* output) {
-  HANDLE out_read = NULL;
-  HANDLE out_write = NULL;
+  HANDLE out_read = nullptr;
+  HANDLE out_write = nullptr;
 
   SECURITY_ATTRIBUTES sa_attr;
   // Set the bInheritHandle flag so pipe handles are inherited.
   sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
   sa_attr.bInheritHandle = TRUE;
-  sa_attr.lpSecurityDescriptor = NULL;
+  sa_attr.lpSecurityDescriptor = nullptr;
 
   // Create the pipe for the child process's STDOUT.
   if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
     NOTREACHED() << "Failed to create pipe";
     return false;
   }
 
   // Ensure we don't leak the handles.
   win::ScopedHandle scoped_out_read(out_read);
   win::ScopedHandle scoped_out_write(out_write);
@@ skipping 15 matching lines @@
   start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
   if (include_stderr) {
     start_info.hStdError = out_write;
   } else {
     start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
   }
   start_info.dwFlags |= STARTF_USESTDHANDLES;
 
   // Create the child process.
   PROCESS_INFORMATION temp_process_info = {};
-  if (!CreateProcess(NULL,
-                     &writable_command_line_string[0],
-                     NULL, NULL,
+  if (!CreateProcess(nullptr, &writable_command_line_string[0], nullptr,
+                     nullptr,
                      TRUE,  // Handles are inherited.
-                     0, NULL, NULL, &start_info, &temp_process_info)) {
+                     0, nullptr, nullptr, &start_info, &temp_process_info)) {
     NOTREACHED() << "Failed to start process";
     return false;
   }
   base::win::ScopedProcessInformation proc_info(temp_process_info);
 
   // Close our writing end of pipe now. Otherwise later read would not be able
   // to detect end of child's output.
   scoped_out_write.Close();
 
   // Read output from the child process's pipe for STDOUT
   const int kBufferSize = 1024;
   char buffer[kBufferSize];
 
   for (;;) {
     DWORD bytes_read = 0;
-    BOOL success = ReadFile(out_read, buffer, kBufferSize, &bytes_read, NULL);
+    BOOL success =
+        ReadFile(out_read, buffer, kBufferSize, &bytes_read, nullptr);
     if (!success || bytes_read == 0)
       break;
     output->append(buffer, bytes_read);
   }
 
   // Let's wait for the process to finish.
   WaitForSingleObject(proc_info.process_handle(), INFINITE);
 
   int exit_code;
   base::TerminationStatus status = GetTerminationStatus(
@@ skipping 55 matching lines @@
       return;
     }
   }
 
   // Arbitrary byte count to use when buffering output lines.  More
   // means potential waste, less means more risk of interleaved
   // log-lines in output.
   enum { kOutputBufferSize = 64 * 1024 };
 
   if (freopen("CONOUT$", "w", stdout)) {
-    setvbuf(stdout, NULL, _IOLBF, kOutputBufferSize);
+    setvbuf(stdout, nullptr, _IOLBF, kOutputBufferSize);
     // Overwrite FD 1 for the benefit of any code that uses this FD
     // directly.  This is safe because the CRT allocates FDs 0, 1 and
     // 2 at startup even if they don't have valid underlying Windows
     // handles.  This means we won't be overwriting an FD created by
     // _open() after startup.
     _dup2(_fileno(stdout), 1);
   }
   if (freopen("CONOUT$", "w", stderr)) {
-    setvbuf(stderr, NULL, _IOLBF, kOutputBufferSize);
+    setvbuf(stderr, nullptr, _IOLBF, kOutputBufferSize);
     _dup2(_fileno(stderr), 2);
   }
 
   // Fix all cout, wcout, cin, wcin, cerr, wcerr, clog and wclog.
   std::ios::sync_with_stdio();
 }
 
 Process LaunchProcess(const CommandLine& cmdline,
                       const LaunchOptions& options) {
   return LaunchProcess(cmdline.GetCommandLineString(), options);
@@ skipping 72 matching lines @@
     // releases that do not support nested jobs.
     if (win::GetVersion() < win::VERSION_WIN8)
       flags |= CREATE_BREAKAWAY_FROM_JOB;
   }
 
   if (options.force_breakaway_from_job_)
     flags |= CREATE_BREAKAWAY_FROM_JOB;
 
   PROCESS_INFORMATION temp_process_info = {};
 
+  LPCTSTR current_directory = options.current_directory.empty()
+                                  ? nullptr
+                                  : options.current_directory.value().c_str();
+
   string16 writable_cmdline(cmdline);
   if (options.as_user) {
     flags |= CREATE_UNICODE_ENVIRONMENT;
-    void* enviroment_block = NULL;
+    void* enviroment_block = nullptr;
 
     if (!CreateEnvironmentBlock(&enviroment_block, options.as_user, FALSE)) {
       DPLOG(ERROR);
       return Process();
     }
 
-    BOOL launched =
-        CreateProcessAsUser(options.as_user, NULL,
-                            &writable_cmdline[0],
-                            NULL, NULL, inherit_handles, flags,
-                            enviroment_block, NULL, startup_info,
-                            &temp_process_info);
+    BOOL launched = CreateProcessAsUser(
+        options.as_user, nullptr, &writable_cmdline[0], nullptr, nullptr,
+        inherit_handles, flags, enviroment_block, current_directory,
+        startup_info, &temp_process_info);
     DestroyEnvironmentBlock(enviroment_block);
     if (!launched) {
       DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
                    << std::endl;
       return Process();
     }
   } else {
-    if (!CreateProcess(NULL,
-                       &writable_cmdline[0], NULL, NULL,
-                       inherit_handles, flags, NULL, NULL,
+    if (!CreateProcess(nullptr, &writable_cmdline[0], nullptr, nullptr,
+                       inherit_handles, flags, nullptr, current_directory,
                        startup_info, &temp_process_info)) {
       DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
                    << std::endl;
       return Process();
     }
   }
   base::win::ScopedProcessInformation process_info(temp_process_info);
 
   if (options.job_handle) {
     if (0 == AssignProcessToJobObject(options.job_handle,
@@ skipping 18 matching lines @@
   const string16 file = cmdline.GetProgram().value();
   const string16 arguments = cmdline.GetArgumentsString();
 
   SHELLEXECUTEINFO shex_info = {};
   shex_info.cbSize = sizeof(shex_info);
   shex_info.fMask = SEE_MASK_NOCLOSEPROCESS;
   shex_info.hwnd = GetActiveWindow();
   shex_info.lpVerb = L"runas";
   shex_info.lpFile = file.c_str();
   shex_info.lpParameters = arguments.c_str();
-  shex_info.lpDirectory = NULL;
+  shex_info.lpDirectory = nullptr;
   shex_info.nShow = options.start_hidden ? SW_HIDE : SW_SHOW;
-  shex_info.hInstApp = NULL;
+  shex_info.hInstApp = nullptr;
 
   if (!ShellExecuteEx(&shex_info)) {
     DPLOG(ERROR);
     return Process();
   }
 
   if (options.wait)
     WaitForSingleObject(shex_info.hProcess, INFINITE);
 
   return Process(shex_info.hProcess);
@@ skipping 19 matching lines @@
 
 bool GetAppOutput(const StringPiece16& cl, std::string* output) {
   return GetAppOutputInternal(cl, false, output);
 }
 
 void RaiseProcessToHighPriority() {
   SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 }
 
 }  // namespace base