Win should call ::TerminateProcess to exit a renderer process

base/process/process_unittest.cc

 // Copyright 2014 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/process.h"
 
 #include <utility>
 
 #include "base/process/kill.h"
 #include "base/test/multiprocess_test.h"
@@ skipping 130 matching lines @@
                                  &exit_code);
 
   EXPECT_NE(TERMINATION_STATUS_STILL_RUNNING,
             GetTerminationStatus(process.Handle(), &exit_code));
 #if !defined(OS_POSIX)
   // The POSIX implementation actually ignores the exit_code.
   EXPECT_EQ(kExpectedExitCode, exit_code);
 #endif
 }
 
+MULTIPROCESS_TEST_MAIN(TerminateCurrentProcessImmediately) {
+  // PlatformThread::Sleep(TestTimeouts::action_max_timeout());
+  int kExpectedExitCode = 250;
+  Process::TerminateCurrentProcessImmediately(kExpectedExitCode);
+  return 0;
+}
+
+TEST_F(ProcessTest, TerminateCurrentProcessImmediately) {
+  Process process(SpawnChild("TerminateCurrentProcessImmediately"));
+  ASSERT_TRUE(process.IsValid());
+
+  const int kDummyExitCode = 42;
+  int exit_code = kDummyExitCode;
+  EXPECT_EQ(TERMINATION_STATUS_STILL_RUNNING,
+            GetTerminationStatus(process.Handle(), &exit_code));
+  EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
+
+  exit_code = kDummyExitCode;
+  process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
+                                 &exit_code);
+
+  EXPECT_NE(TERMINATION_STATUS_STILL_RUNNING,
+            GetTerminationStatus(process.Handle(), &exit_code));
+#if !defined(OS_POSIX)

[haraken, 2017/01/17 09:40:27]

It looks like this guard is needed. In Linux, exit_code is 0 here.

[Primiano Tucci (use gerrit), 2017/01/17 12:08:21]

I insist, on linux the exit code works really fine. The problem is that here you
are creating a race because you first wait for the process to exit and then get
its termination status. you cannot detect the termination status twice.
If you did build this in debug with logging, you would have seen this:
[16030:16030:0117/113305.527613:1125986610551:ERROR:kill_posix.cc(34)]
waitpid(16031): No child processes

so what happens is that you are getting 0 because you make the process go away
with the first call to WaitForExitWithTimeout and then you poll a non existing
process with GetTerminationStatus.

I think you here want to super-simplify this:

-----
MULTIPROCESS_TEST_MAIN(TerminateCurrentProcessImmediatelyWithCode0) {
  Process::TerminateCurrentProcessImmediately(0);
  NOTREACHED();
  return 42;
}

TEST_F(ProcessTest, TerminateCurrentProcessImmediatelyWithZeroExitCode) {
  Process process(SpawnChild("TerminateCurrentProcessImmediatelyWithCode0"));
  ASSERT_TRUE(process.IsValid());
  int exit_code = 42;
  ASSERT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
                                             &exit_code));
  EXPECT_EQ(0, exit_code);
}

MULTIPROCESS_TEST_MAIN(TerminateCurrentProcessImmediatelyWithCode250) {
  Process::TerminateCurrentProcessImmediately(250);
  NOTREACHED();
  return 42;
}

TEST_F(ProcessTest, TerminateCurrentProcessImmediatelyWithNonZeroExitCode) {
  Process process(SpawnChild("TerminateCurrentProcessImmediatelyWithCode250"));
  ASSERT_TRUE(process.IsValid());
  int exit_code = 42;
  ASSERT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
                                             &exit_code));
  EXPECT_EQ(250, exit_code);
}
-----

I tried this in my linux workstation and it works

+  // The POSIX implementation actually ignores the exit_code.
+  EXPECT_EQ(kExpectedExitCode, exit_code);
+#endif
+}
+
 MULTIPROCESS_TEST_MAIN(FastSleepyChildProcess) {
   PlatformThread::Sleep(TestTimeouts::tiny_timeout() * 10);
   return 0;
 }
 
 TEST_F(ProcessTest, WaitForExit) {
   Process process(SpawnChild("FastSleepyChildProcess"));
   ASSERT_TRUE(process.IsValid());
 
   const int kDummyExitCode = 42;
@@ skipping 86 matching lines @@
       "2:freezer:/chrome_renderers/to_be_frozen\n"
       "1:cpu:/chrome_renderers/background\n";
 
   EXPECT_FALSE(IsProcessBackgroundedCGroup(kNotBackgrounded));
   EXPECT_TRUE(IsProcessBackgroundedCGroup(kBackgrounded));
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace base