Win should call ::TerminateProcess to exit a renderer process

base/process/process_posix.cc

Index: base/process/process_posix.cc
diff --git a/base/process/process_posix.cc b/base/process/process_posix.cc
index 55b7ac90e2952de74c28408c90163b727ca7cdc5..689252b105cd5668b3cd0843a7228d5e1ed89d2b 100644
--- a/base/process/process_posix.cc
+++ b/base/process/process_posix.cc
@@ -350,6 +350,10 @@ bool Process::Terminate(int exit_code, bool wait) const {
 }
 #endif  // !defined(OS_NACL_NONSFI)
 
+void Process::TerminateImmediately(int exit_code) const {
+  _exit(0);

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

two things here:
1) s/0/exit_code/ :)
2) note that in the current API Process is an object that can be a remote
process, not the current one.
The way this is implemented  is a bit contra-intuitive beause you can do

Process another = Process.Open(...)
another.TerminateImmediately()

the expectation in this case is that it would terminate immediately the |other|
process. Instead this will terminate the current one, leaving everybody
amazingly surprised.

I think the possible ways to deal with this is:

1) Make this a static method and call it TerminateCurrentProcessImmediately
2) CHECK(is_current()) << "Immediate termination of another process is not a
supported use case")
3) Just kill(process_, SIGKILL) (in which case I'd refactor and extract the
common code from ::Terminate instead of duplicating)

3 has a small drawback, when you SIGKILL the process will exit immediately, but
with an exit code of != 0 (specifically 137 if I did the math correctly). Not
sure if this (the fact that a child dies with != 0) will confuse the browser
process, letting it kill that the process was killed by an external event
(concretely if we have any sort of code that tries to account child processes
OOM, this might be confused for a kill due to OOM)

Very likely terminating immediately another process is not a use case that we
care about, so I would go either for 1 or for 2. 

[Nico, 2017/01/13 19:24:59]

Agreed, 1 or 2 seem more appropriate. 1 seems a tiny bit simpler to me, but up
to you.

+}
+
 bool Process::WaitForExit(int* exit_code) const {
   return WaitForExitWithTimeout(TimeDelta::Max(), exit_code);
 }