Assume session is ending when receiving SIGTERM on Linux

See the comments added in this CL for details.

BUG=429404
R=sky

Change-Id: Icc5bad8e70853a62f76640b111a89f9e6b487d4b
Reviewed-on: https://chromium-review.googlesource.com/c/1481125
Commit-Queue: Thomas Anderson <thomasanderson@chromium.org>
Auto-Submit: Thomas Anderson <thomasanderson@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Cr-Commit-Position: refs/heads/master@{#636525}

chrome/app/shutdown_signal_handlers_posix.cc

@@ -9,6 +9,8 @@
 #include <string.h>
 #include <unistd.h>
 
+#include <utility>
+
 #include "base/callback.h"
 #include "base/debug/leak_annotations.h"
 #include "base/logging.h"
@@ -74,7 +76,7 @@ class ShutdownDetector : public base::PlatformThread::Delegate {
  public:
   ShutdownDetector(
       int shutdown_fd,
-      const base::Closure& shutdown_callback,
+      base::OnceCallback<void(int)> shutdown_callback,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
   ~ShutdownDetector() override;
 
@@ -83,7 +85,7 @@ class ShutdownDetector : public base::PlatformThread::Delegate {
 
  private:
   const int shutdown_fd_;
-  const base::Closure shutdown_callback_;
+  base::OnceCallback<void(int)> shutdown_callback_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownDetector);
@@ -91,13 +93,13 @@ class ShutdownDetector : public base::PlatformThread::Delegate {
 
 ShutdownDetector::ShutdownDetector(
     int shutdown_fd,
-    const base::Closure& shutdown_callback,
+    base::OnceCallback<void(int)> shutdown_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : shutdown_fd_(shutdown_fd),
-      shutdown_callback_(shutdown_callback),
+      shutdown_callback_(std::move(shutdown_callback)),
       task_runner_(task_runner) {
   CHECK_NE(shutdown_fd_, -1);
-  CHECK(!shutdown_callback.is_null());
+  CHECK(!shutdown_callback_.is_null());
   CHECK(task_runner_);
 }
 
@@ -146,7 +148,8 @@ void ShutdownDetector::ThreadMain() {
   } while (bytes_read < sizeof(signal));
   VLOG(1) << "Handling shutdown for signal " << signal << ".";
 
-  if (!task_runner_->PostTask(FROM_HERE, shutdown_callback_)) {
+  if (!task_runner_->PostTask(
+          FROM_HERE, base::BindOnce(std::move(shutdown_callback_), signal))) {
     // Without a valid task runner to post the exit task to, there aren't many
     // options. Raise the signal again. The default handler will pick it up
     // and cause an ungraceful exit.
@@ -172,7 +175,7 @@ void ShutdownDetector::ThreadMain() {
 }  // namespace
 
 void InstallShutdownSignalHandlers(
-    const base::Closure& shutdown_callback,
+    base::OnceCallback<void(int)> shutdown_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
   int pipefd[2];
   int ret = pipe(pipefd);
@@ -191,7 +194,7 @@ void InstallShutdownSignalHandlers(
   const size_t kShutdownDetectorThreadStackSize = PTHREAD_STACK_MIN * 4;
 #endif
   ShutdownDetector* detector = new ShutdownDetector(
-      g_shutdown_pipe_read_fd, shutdown_callback, task_runner);
+      g_shutdown_pipe_read_fd, std::move(shutdown_callback), task_runner);
   // PlatformThread does not delete its delegate.
   ANNOTATE_LEAKING_OBJECT_PTR(detector);
   if (!base::PlatformThread::CreateNonJoinable(kShutdownDetectorThreadStackSize,
@@ -211,15 +214,15 @@ void InstallShutdownSignalHandlers(
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   action.sa_handler = SIGTERMHandler;
-  CHECK(sigaction(SIGTERM, &action, nullptr) == 0);
+  CHECK_EQ(0, sigaction(SIGTERM, &action, nullptr));
 
   // Also handle SIGINT - when the user terminates the browser via Ctrl+C. If
   // the browser process is being debugged, GDB will catch the SIGINT first.
   action.sa_handler = SIGINTHandler;
-  CHECK(sigaction(SIGINT, &action, nullptr) == 0);
+  CHECK_EQ(0, sigaction(SIGINT, &action, nullptr));
 
   // And SIGHUP, for when the terminal disappears. On shutdown, many Linux
   // distros send SIGHUP, SIGTERM, and then SIGKILL.
   action.sa_handler = SIGHUPHandler;
-  CHECK(sigaction(SIGHUP, &action, nullptr) == 0);
+  CHECK_EQ(0, sigaction(SIGHUP, &action, nullptr));
 }

chrome/app/shutdown_signal_handlers_posix.h

@@ -16,7 +16,7 @@ class SingleThreadTaskRunner;
 // signals like SIGTERM, SIGINT and SIGTERM. |shutdown_callback| is invoked on
 // |task_runner| which is usually the main thread's task runner.
 void InstallShutdownSignalHandlers(
-    const base::Closure& shutdown_callback,
+    base::OnceCallback<void(int)> shutdown_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
 
 #endif  // CHROME_APP_SHUTDOWN_SIGNAL_HANDLERS_POSIX_H_

chrome/browser/chrome_browser_main_posix.cc

@@ -40,7 +40,7 @@ void SIGCHLDHandler(int signal) {
 class ExitHandler {
  public:
   // Invokes exit when appropriate.
-  static void ExitWhenPossibleOnUIThread();
+  static void ExitWhenPossibleOnUIThread(int signal);
 
  private:
   ExitHandler();
@@ -64,13 +64,38 @@ class ExitHandler {
 };
 
 // static
-void ExitHandler::ExitWhenPossibleOnUIThread() {
+void ExitHandler::ExitWhenPossibleOnUIThread(int signal) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (SessionRestore::IsRestoringSynchronously()) {
     // ExitHandler takes care of deleting itself.
     new ExitHandler();
   } else {
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+    switch (signal) {
+      case SIGINT:
+      case SIGHUP:
+        // SIGINT gets sent when the user types Ctrl+C, but the session is
+        // likely not going away, so try to exit gracefully.  SIGHUP is sent on
+        // most systems as a first warning of shutdown.  If the process takes
+        // too long to quit, the next signal is usually SIGTERM.
+        Exit();
+        break;
+      case SIGTERM:
+        // SIGTERM is usually sent instead of SIGKILL to gracefully shutdown
+        // processes.  But most systems use it as a shutdown warning, so
+        // conservatively assume that the session is ending.  If the process
+        // still doesn't quit within a bounded time, most systems will finally
+        // send SIGKILL, which we're unable to install a signal handler for.
+        // TODO(thomasanderson): Try to distinguish if the session is really
+        // ending or not.  Maybe there's a systemd or DBus API to query.
+        chrome::SessionEnding();
+        break;
+      default:
+        NOTREACHED();
+    }
+#else
     Exit();
+#endif
   }
 }
 
@@ -125,7 +150,7 @@ int ChromeBrowserMainPartsPosix::PreEarlyInitialization() {
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   action.sa_handler = SIGCHLDHandler;
-  CHECK(sigaction(SIGCHLD, &action, NULL) == 0);
+  CHECK_EQ(0, sigaction(SIGCHLD, &action, NULL));
 
   return service_manager::RESULT_CODE_NORMAL_EXIT;
 }
@@ -135,7 +160,7 @@ void ChromeBrowserMainPartsPosix::PostMainMessageLoopStart() {
 
   // Exit in response to SIGINT, SIGTERM, etc.
   InstallShutdownSignalHandlers(
-      base::Bind(&ExitHandler::ExitWhenPossibleOnUIThread),
+      base::BindOnce(&ExitHandler::ExitWhenPossibleOnUIThread),
       base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::UI}));
 }
 

chrome/browser/first_run/first_run_internal_posix_browsertest.cc

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/test/base/in_process_browser_test.h"
-
 #include <signal.h>
 
 #include "base/bind.h"
@@ -65,7 +63,7 @@ class FirstRunInternalPosixTest : public InProcessBrowserTest {
     // Send a signal to myself. This should post a task for the next run loop
     // iteration to set browser_shutdown::IsTryingToQuit(), and interrupt the
     // RunLoop.
-    raise(SIGTERM);
+    raise(SIGINT);
     inspected_state_ = true;
   }
 
@@ -77,7 +75,7 @@ class FirstRunInternalPosixTest : public InProcessBrowserTest {
 // Test the first run flow for showing the modal dialog that surfaces the first
 // run dialog. Ensure browser startup safely handles a signal while the modal
 // RunLoop is running.
-IN_PROC_BROWSER_TEST_F(FirstRunInternalPosixTest, HandleSigterm) {
+IN_PROC_BROWSER_TEST_F(FirstRunInternalPosixTest, HandleSigint) {
   // Never reached. PreMainMessageLoopRunImpl() should return before this task
   // is run.
   ADD_FAILURE() << "Should never be called";