Hacky slashy

base/test/launcher/test_launcher.cc

 // Copyright 2013 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/test/launcher/test_launcher.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 43 matching lines @@
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
+#if defined(OS_FUCHSIA)
+#include <magenta/process.h>
+#include <magenta/syscalls.h>
+#endif
+
 namespace base {
 
 // See https://groups.google.com/a/chromium.org/d/msg/chromium-dev/nkdTP7sstSc/uT3FaE_sgkAJ .
 using ::operator<<;
 
 // The environment variable name for the total number of test shards.
 const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
 // The environment variable name for the test shard index.
 const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
 
@@ skipping 33 matching lines @@
   static auto* map = new std::map<ProcessHandle, CommandLine>;
   return map;
 }
 
 // Performance trace generator.
 TestLauncherTracer* GetTestLauncherTracer() {
   static auto* tracer = new TestLauncherTracer;
   return tracer;
 }
 
-#if defined(OS_POSIX)
+#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
 // Self-pipe that makes it possible to do complex shutdown handling
 // outside of the signal handler.
 int g_shutdown_pipe[2] = { -1, -1 };
 
 void ShutdownPipeSignalHandler(int signal) {
   HANDLE_EINTR(write(g_shutdown_pipe[1], "q", 1));
 }
 
 void KillSpawnedTestProcesses() {
   // Keep the lock until exiting the process to prevent further processes
@@ skipping 161 matching lines @@
 
     if (!SetJobObjectLimitFlags(job_handle.Get(), job_flags)) {
       LOG(ERROR) << "Could not SetJobObjectLimitFlags.";
       return -1;
     }
 
     new_options.job_handle = job_handle.Get();
   }
 #endif  // defined(OS_WIN)
 
+#if defined(OS_FUCHSIA)
+  DCHECK_EQ(new_options.job_handle, MX_HANDLE_INVALID);
+  if (flags & TestLauncher::USE_JOB_OBJECTS) {
+    mx_status_t status =
+        mx_job_create(mx_job_default(), 0, &new_options.job_handle);
+    if (status < 0) {
+      LOG(ERROR) << "Failed to create job object";
+      return -1;
+    }
+  }
+#endif
+
 #if defined(OS_LINUX)
   // To prevent accidental privilege sharing to an untrusted child, processes
   // are started with PR_SET_NO_NEW_PRIVS. Do not set that here, since this
   // new child will be privileged and trusted.
   new_options.allow_new_privs = true;
 #endif
 
   Process process;
 
   {
@@ skipping 40 matching lines @@
     // Ensure that the process terminates.
     process.Terminate(-1, true);
   }
 
   {
     // Note how we grab the log before issuing a possibly broad process kill.
     // Other code parts that grab the log kill processes, so avoid trying
     // to do that twice and trigger all kinds of log messages.
     AutoLock lock(*GetLiveProcessesLock());
 
-#if defined(OS_POSIX)
+#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
     if (exit_code != 0) {
       // On POSIX, in case the test does not exit cleanly, either due to a crash
       // or due to it timing out, we need to clean up any child processes that
       // it might have created. On Windows, child processes are automatically
       // cleaned up using JobObjects.
       KillProcessGroup(process.Handle());
     }
 #endif
 
     GetLiveProcesses()->erase(process.Handle());
@@ skipping 147 matching lines @@
 TestLauncher::~TestLauncher() {}
 
 bool TestLauncher::Run() {
   if (!Init())
     return false;
 
   // Value of |cycles_| changes after each iteration. Keep track of the
   // original value.
   int requested_cycles = cycles_;
 
-#if defined(OS_POSIX)
+#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
   CHECK_EQ(0, pipe(g_shutdown_pipe));
 
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   sigemptyset(&action.sa_mask);
   action.sa_handler = &ShutdownPipeSignalHandler;
 
   CHECK_EQ(0, sigaction(SIGINT, &action, NULL));
   CHECK_EQ(0, sigaction(SIGQUIT, &action, NULL));
   CHECK_EQ(0, sigaction(SIGTERM, &action, NULL));
@@ skipping 134 matching lines @@
       result.status == TestResult::TEST_UNKNOWN) {
     test_broken_count_++;
   }
   size_t broken_threshold =
       std::max(static_cast<size_t>(20), test_found_count_ / 10);
   if (!force_run_broken_tests_ && test_broken_count_ >= broken_threshold) {
     fprintf(stdout, "Too many badly broken tests (%" PRIuS "), exiting now.\n",
             test_broken_count_);
     fflush(stdout);
 
-#if defined(OS_POSIX)
+#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
     KillSpawnedTestProcesses();
 #endif  // defined(OS_POSIX)
 
     MaybeSaveSummaryAsJSON({"BROKEN_TEST_EARLY_EXIT", kUnreliableResultsTag});
 
     exit(1);
   }
 
   if (test_finished_count_ != test_started_count_)
     return;
@@ skipping 519 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base