Set current directory when launching Native Messaging processes.

base/process/process_util_unittest.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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 114 matching lines @@
     base::PlatformThread::Sleep(kInterval);
     waited += kInterval;
   } while (status == base::TERMINATION_STATUS_STILL_RUNNING &&
            waited < TestTimeouts::action_max_timeout());
 
   return status;
 }
 
 }  // namespace
 
+const int kSuccess = 0;
+
 class ProcessUtilTest : public base::MultiProcessTest {
  public:
 #if defined(OS_POSIX)
   // Spawn a child process that counts how many file descriptors are open.
   int CountOpenFDsInChild();
 #endif
   // Converts the filename to a platform specific filepath.
   // On Android files can not be created in arbitrary directories.
   static std::string GetSignalFilePath(const char* filename);
 };
 
 std::string ProcessUtilTest::GetSignalFilePath(const char* filename) {
 #if !defined(OS_ANDROID)
   return filename;
 #else
   FilePath tmp_dir;
   PathService::Get(base::DIR_CACHE, &tmp_dir);
   tmp_dir = tmp_dir.Append(filename);
   return tmp_dir.value();
 #endif
 }
 
 MULTIPROCESS_TEST_MAIN(SimpleChildProcess) {
-  return 0;
+  return kSuccess;
 }
 
 // TODO(viettrungluu): This should be in a "MultiProcessTestTest".
 TEST_F(ProcessUtilTest, SpawnChild) {
   base::Process process = SpawnChild("SimpleChildProcess");
   ASSERT_TRUE(process.IsValid());
   int exit_code;
   EXPECT_TRUE(process.WaitForExitWithTimeout(
                   TestTimeouts::action_max_timeout(), &exit_code));
 }
 
 MULTIPROCESS_TEST_MAIN(SlowChildProcess) {
   WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileSlow).c_str());
-  return 0;
+  return kSuccess;
 }
 
 TEST_F(ProcessUtilTest, KillSlowChild) {
   const std::string signal_file =
       ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
   remove(signal_file.c_str());
   base::Process process = SpawnChild("SlowChildProcess");
   ASSERT_TRUE(process.IsValid());
   SignalChildren(signal_file.c_str());
   int exit_code;
@@ skipping 13 matching lines @@
   int exit_code = 42;
   EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
             base::GetTerminationStatus(process.Handle(), &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
       WaitForChildTermination(process.Handle(), &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_NORMAL_TERMINATION, status);
-  EXPECT_EQ(0, exit_code);
+  EXPECT_EQ(kSuccess, exit_code);
   remove(signal_file.c_str());
 }
 
+// On Android SpawnProcess() doesn't use LaunchProcess() and doesn't support
+// LaunchOptions::current_directory.
+#if !defined(OS_ANDROID)
+MULTIPROCESS_TEST_MAIN(CheckCwdProcess) {
+  base::FilePath expected;
+  CHECK(base::GetTempDir(&expected));
+  expected = MakeAbsoluteFilePath(expected);
+  CHECK(!expected.empty());
+
+  base::FilePath actual;
+  CHECK(base::GetCurrentDirectory(&actual));
+  actual = MakeAbsoluteFilePath(actual);
+  CHECK(!actual.empty());
+
+  CHECK(expected == actual) << "Expected: " << expected.value()
+                            << "  Actual: " << actual.value();
+  return kSuccess;
+}
+
+TEST_F(ProcessUtilTest, CurrentDirectory) {
+  // TODO(rickyz): Add support for passing arguments to multiprocess children,
+  // then create a special directory for this test.
+  base::FilePath tmp_dir;
+  ASSERT_TRUE(base::GetTempDir(&tmp_dir));
+
+  base::LaunchOptions options;
+  options.current_directory = tmp_dir;
+
+  base::Process process(SpawnChildWithOptions("CheckCwdProcess", options));
+  ASSERT_TRUE(process.IsValid());
+
+  int exit_code = 42;
+  EXPECT_TRUE(process.WaitForExit(&exit_code));
+  EXPECT_EQ(kSuccess, exit_code);
+}
+#endif  // !defined(OS_ANDROID)
+
 #if defined(OS_WIN)
 // TODO(cpu): figure out how to test this in other platforms.
 TEST_F(ProcessUtilTest, GetProcId) {
   base::ProcessId id1 = base::GetProcId(GetCurrentProcess());
   EXPECT_NE(0ul, id1);
   base::Process process = SpawnChild("SimpleChildProcess");
   ASSERT_TRUE(process.IsValid());
   base::ProcessId id2 = process.Pid();
   EXPECT_NE(0ul, id2);
   EXPECT_NE(id1, id2);
 }
-#endif
+#endif  // defined(OS_WIN)
 
 #if !defined(OS_MACOSX)
 // This test is disabled on Mac, since it's flaky due to ReportCrash
 // taking a variable amount of time to parse and load the debug and
 // symbol data for this unit test's executable before firing the
 // signal handler.
 //
 // TODO(gspencer): turn this test process into a very small program
 // with no symbols (instead of using the multiprocess testing
 // framework) to reduce the ReportCrash overhead.
@@ skipping 77 matching lines @@
   return 1;
 }
 
 #if defined(OS_POSIX)
 MULTIPROCESS_TEST_MAIN(TerminatedChildProcess) {
   WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileTerm).c_str());
   // Send a SIGTERM to this process.
   ::kill(getpid(), SIGTERM);
   return 1;
 }
-#endif
+#endif  // defined(OS_POSIX)
 
 TEST_F(ProcessUtilTest, GetTerminationStatusSigKill) {
   const std::string signal_file =
     ProcessUtilTest::GetSignalFilePath(kSignalFileKill);
   remove(signal_file.c_str());
   base::Process process = SpawnChild("KilledChildProcess");
   ASSERT_TRUE(process.IsValid());
 
   int exit_code = 42;
   EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
@@ skipping 39 matching lines @@
   base::TerminationStatus status =
       WaitForChildTermination(process.Handle(), &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
 
   int signaled = WIFSIGNALED(exit_code);
   EXPECT_NE(0, signaled);
   int signal = WTERMSIG(exit_code);
   EXPECT_EQ(SIGTERM, signal);
   remove(signal_file.c_str());
 }
-#endif
+#endif  // defined(OS_POSIX)
 
 #if defined(OS_WIN)
 // TODO(estade): if possible, port this test.
 TEST_F(ProcessUtilTest, GetAppOutput) {
   // Let's create a decently long message.
   std::string message;
   for (int i = 0; i < 1025; i++) {  // 1025 so it does not end on a kilo-byte
                                     // boundary.
     message += "Hello!";
   }
@@ skipping 162 matching lines @@
   if (ret == -1)
     return false;
 
   // Remove the guard.  It should not be possible to fail in removing the guard
   // just added.
   ret = change_fdguard_np(fd, &kGuard, GUARD_DUP, NULL, 0, &original_fdflags);
   DPCHECK(ret == 0);
 
   return true;
 }
-#endif  // OS_MACOSX
+#endif  // defined(OS_MACOSX)
 
 }  // namespace
 
 MULTIPROCESS_TEST_MAIN(ProcessUtilsLeakFDChildProcess) {
   // This child process counts the number of open FDs, it then writes that
   // number out to a pipe connected to the parent.
   int num_open_files = 0;
   int write_pipe = kChildPipe;
   int max_files = GetMaxFilesOpenInProcess();
   for (int i = STDERR_FILENO + 1; i < max_files; i++) {
@@ skipping 56 matching lines @@
   return num_open_files;
 }
 
 #if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)
 // ProcessUtilTest.FDRemapping is flaky when ran under xvfb-run on Precise.
 // The problem is 100% reproducible with both ASan and TSan.
 // See http://crbug.com/136720.
 #define MAYBE_FDRemapping DISABLED_FDRemapping
 #else
 #define MAYBE_FDRemapping FDRemapping
-#endif
+#endif  // defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)
 TEST_F(ProcessUtilTest, MAYBE_FDRemapping) {
   int fds_before = CountOpenFDsInChild();
 
   // open some dummy fds to make sure they don't propagate over to the
   // child process.
   int dev_null = open("/dev/null", O_RDONLY);
   int sockets[2];
   socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
 
   int fds_after = CountOpenFDsInChild();
@@ skipping 23 matching lines @@
   fds_to_remap.push_back(std::make_pair(fds[1], 1));
   base::LaunchOptions options;
   options.wait = true;
   options.environ = env_changes;
   options.clear_environ = clear_environ;
   options.fds_to_remap = &fds_to_remap;
 #if defined(OS_LINUX)
   options.clone_flags = clone_flags;
 #else
   CHECK_EQ(0, clone_flags);
-#endif  // OS_LINUX
+#endif  // defined(OS_LINUX)
   EXPECT_TRUE(base::LaunchProcess(args, options).IsValid());
   PCHECK(IGNORE_EINTR(close(fds[1])) == 0);
 
   char buf[512];
   const ssize_t n = HANDLE_EINTR(read(fds[0], buf, sizeof(buf)));
 
   PCHECK(IGNORE_EINTR(close(fds[0])) == 0);
 
   return std::string(buf, n);
 }
@@ skipping 65 matching lines @@
 
   EXPECT_EQ(
       "BASE_TEST=wibble\n",
       TestLaunchProcess(
           print_env, env_changes, true /* clear_environ */, no_clone_flags));
   env_changes.clear();
   EXPECT_EQ(
       "",
       TestLaunchProcess(
           print_env, env_changes, true /* clear_environ */, no_clone_flags));
-#endif
+#endif  // defined(OS_LINUX)
 }
 
 TEST_F(ProcessUtilTest, GetAppOutput) {
   std::string output;
 
 #if defined(OS_ANDROID)
   std::vector<std::string> argv;
   argv.push_back("sh");  // Instead of /bin/sh, force path search to find it.
   argv.push_back("-c");
 
@@ skipping 87 matching lines @@
   std::vector<std::string> argv;
   std::string output;
 
   argv.push_back(std::string(kShellPath));  // argv[0]
   argv.push_back("-c");
 #if defined(OS_ANDROID)
   argv.push_back("while echo 12345678901234567890; do :; done");
   EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
                                            10));
   EXPECT_STREQ("1234567890", output.c_str());
-#else
+#else  // defined(OS_ANDROID)
   argv.push_back("yes");
   EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
                                            10));
   EXPECT_STREQ("y\ny\ny\ny\ny\n", output.c_str());
-#endif
+#endif  // !defined(OS_ANDROID)
 }
-#endif
+#endif  // !defined(OS_MACOSX) && !defined(OS_OPENBSD)
 
 #if defined(ADDRESS_SANITIZER) && defined(OS_MACOSX) && \
     defined(ARCH_CPU_64_BITS)
 // Times out under AddressSanitizer on 64-bit OS X, see
 // http://crbug.com/298197.
 #define MAYBE_GetAppOutputRestrictedNoZombies \
     DISABLED_GetAppOutputRestrictedNoZombies
 #else
 #define MAYBE_GetAppOutputRestrictedNoZombies GetAppOutputRestrictedNoZombies
 #endif
@@ skipping 26 matching lines @@
   // Test getting output from a successful application.
   std::vector<std::string> argv;
   std::string output;
   int exit_code;
   argv.push_back(std::string(kShellPath));  // argv[0]
   argv.push_back("-c");  // argv[1]
   argv.push_back("echo foo");  // argv[2];
   EXPECT_TRUE(base::GetAppOutputWithExitCode(base::CommandLine(argv), &output,
                                              &exit_code));
   EXPECT_STREQ("foo\n", output.c_str());
-  EXPECT_EQ(exit_code, 0);
+  EXPECT_EQ(exit_code, kSuccess);
 
   // Test getting output from an application which fails with a specific exit
   // code.
   output.clear();
   argv[2] = "echo foo; exit 2";
   EXPECT_TRUE(base::GetAppOutputWithExitCode(base::CommandLine(argv), &output,
                                              &exit_code));
   EXPECT_STREQ("foo\n", output.c_str());
   EXPECT_EQ(exit_code, 2);
 }
@@ skipping 21 matching lines @@
                                        &exit_code);
 
   // Check that process was really killed.
   EXPECT_TRUE(IsProcessDead(child_process.Handle()));
 }
 
 MULTIPROCESS_TEST_MAIN(process_util_test_never_die) {
   while (1) {
     sleep(500);
   }
-  return 0;
+  return kSuccess;
 }
 
 TEST_F(ProcessUtilTest, ImmediateTermination) {
   base::Process child_process = SpawnChild("process_util_test_die_immediately");
   ASSERT_TRUE(child_process.IsValid());
   // Give it time to die.
   sleep(2);
   base::EnsureProcessTerminated(child_process.Duplicate());
 
   // Check that process was really killed.
   EXPECT_TRUE(IsProcessDead(child_process.Handle()));
 }
 
 MULTIPROCESS_TEST_MAIN(process_util_test_die_immediately) {
-  return 0;
+  return kSuccess;
 }
 
 #if !defined(OS_ANDROID)
 const char kPipeValue = '\xcc';
 
 class ReadFromPipeDelegate : public base::LaunchOptions::PreExecDelegate {
  public:
   explicit ReadFromPipeDelegate(int fd) : fd_(fd) {}
   ~ReadFromPipeDelegate() override {}
   void RunAsyncSafe() override {
@@ skipping 29 matching lines @@
 
   int exit_code = 42;
   EXPECT_TRUE(process.WaitForExit(&exit_code));
   EXPECT_EQ(0, exit_code);
 }
 #endif  // !defined(OS_ANDROID)
 
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_LINUX)
-const int kSuccess = 0;
-
 MULTIPROCESS_TEST_MAIN(CheckPidProcess) {
   const pid_t kInitPid = 1;
   const pid_t pid = syscall(__NR_getpid);
   CHECK(pid == kInitPid);
   CHECK(getpid() == pid);
   return kSuccess;
 }
 
 #if defined(CLONE_NEWUSER) && defined(CLONE_NEWPID)
 TEST_F(ProcessUtilTest, CloneFlags) {
   if (RunningOnValgrind() ||
       !base::PathExists(FilePath("/proc/self/ns/user")) ||
       !base::PathExists(FilePath("/proc/self/ns/pid"))) {
     // User or PID namespaces are not supported.
     return;
   }
 
   base::LaunchOptions options;
   options.clone_flags = CLONE_NEWUSER | CLONE_NEWPID;
 
   base::Process process(SpawnChildWithOptions("CheckPidProcess", options));
   ASSERT_TRUE(process.IsValid());
 
   int exit_code = 42;
   EXPECT_TRUE(process.WaitForExit(&exit_code));
   EXPECT_EQ(kSuccess, exit_code);
 }
-#endif
+#endif  // defined(CLONE_NEWUSER) && defined(CLONE_NEWPID)
 
 TEST(ForkWithFlagsTest, UpdatesPidCache) {
   // The libc clone function, which allows ForkWithFlags to keep the pid cache
   // up to date, does not work on Valgrind.
   if (RunningOnValgrind()) {
     return;
   }
 
   // Warm up the libc pid cache, if there is one.
   ASSERT_EQ(syscall(__NR_getpid), getpid());
 
   pid_t ctid = 0;
   const pid_t pid =
       base::ForkWithFlags(SIGCHLD | CLONE_CHILD_SETTID, nullptr, &ctid);
   if (pid == 0) {
     // In child.  Check both the raw getpid syscall and the libc getpid wrapper
     // (which may rely on a pid cache).
     RAW_CHECK(syscall(__NR_getpid) == ctid);
     RAW_CHECK(getpid() == ctid);
     _exit(kSuccess);
   }
 
   ASSERT_NE(-1, pid);
   int status = 42;
   ASSERT_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
   ASSERT_TRUE(WIFEXITED(status));
   EXPECT_EQ(kSuccess, WEXITSTATUS(status));
 }
 
-MULTIPROCESS_TEST_MAIN(CheckCwdProcess) {
-  base::FilePath expected;
-  CHECK(base::GetTempDir(&expected));
-  base::FilePath actual;
-  CHECK(base::GetCurrentDirectory(&actual));
-  CHECK(actual == expected);
-  return kSuccess;
-}
-
-TEST_F(ProcessUtilTest, CurrentDirectory) {
-  // TODO(rickyz): Add support for passing arguments to multiprocess children,
-  // then create a special directory for this test.
-  base::FilePath tmp_dir;
-  ASSERT_TRUE(base::GetTempDir(&tmp_dir));
-
-  base::LaunchOptions options;
-  options.current_directory = tmp_dir;
-
-  base::Process process(SpawnChildWithOptions("CheckCwdProcess", options));
-  ASSERT_TRUE(process.IsValid());
-
-  int exit_code = 42;
-  EXPECT_TRUE(process.WaitForExit(&exit_code));
-  EXPECT_EQ(kSuccess, exit_code);
-}
-
 TEST_F(ProcessUtilTest, InvalidCurrentDirectory) {
   base::LaunchOptions options;
   options.current_directory = base::FilePath("/dev/null");
 
   base::Process process(SpawnChildWithOptions("SimpleChildProcess", options));
   ASSERT_TRUE(process.IsValid());
 
   int exit_code = kSuccess;
   EXPECT_TRUE(process.WaitForExit(&exit_code));
   EXPECT_NE(kSuccess, exit_code);
 }
-#endif
+#endif  // defined(OS_LINUX)