Posix: Catch SIGINT and do a clean shutdown....

chrome/browser/browser_main.cc

 // Copyright (c) 2006-2009 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 "chrome/browser/browser_main.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 149 matching lines @@
 #elif defined(OS_POSIX)
   MessageLoopForUI::current()->Run();
 #endif
 }
 
 #if defined(OS_POSIX)
 // See comment in BrowserMain, where sigaction is called.
 void SIGCHLDHandler(int signal) {
 }
 
-// See comment in BrowserMain, where sigaction is called.
-void SIGTERMHandler(int signal) {
-  DCHECK_EQ(signal, SIGTERM);
-  LOG(WARNING) << "Addressing SIGTERM on " << PlatformThread::CurrentId();
+// Common code between SIG{HUP, INT, TERM}Handler.
+void GracefulShutdownHandler(int signal, const int expected_signal) {
+  DCHECK_EQ(signal, expected_signal);
+  LOG(WARNING) << "Addressing signal " << expected_signal << " on "
+               << PlatformThread::CurrentId();
 
   bool posted = ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableFunction(BrowserList::CloseAllBrowsersAndExit));
-  if (posted) {
-    LOG(WARNING) << "Posted task to UI thread; resetting SIGTERM handler";
-  }
 
   // Reinstall the default handler.  We had one shot at graceful shutdown.
   struct sigaction term_action;
   memset(&term_action, 0, sizeof(term_action));
   term_action.sa_handler = SIG_DFL;
-  CHECK(sigaction(SIGTERM, &term_action, NULL) == 0);
+  CHECK(sigaction(expected_signal, &term_action, NULL) == 0);
 
-  if (!posted) {
+  if (posted) {
+    LOG(WARNING) << "Posted task to UI thread; resetting signal "
+                 << expected_signal << " handler";
+  } else {
     // Without a UI thread 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.
     LOG(WARNING) << "No UI thread, exiting ungracefully";
     kill(getpid(), signal);
 
     // The signal may be handled on another thread.  Give that a chance to
     // happen.
     sleep(3);
 
     // We really should be dead by now.  For whatever reason, we're not. Exit
     // immediately, with the exit status set to the signal number with bit 8
     // set.  On the systems that we care about, this exit status is what is
     // normally used to indicate an exit by this signal's default handler.
     // This mechanism isn't a de jure standard, but even in the worst case, it
     // should at least result in an immediate exit.
     LOG(WARNING) << "Still here, exiting really ungracefully";
     _exit(signal | (1 << 7));
   }
 }
 
+// See comment in BrowserMain, where sigaction is called.
+void SIGHUPHandler(int signal) {
+  GracefulShutdownHandler(signal, SIGHUP);
+}
+
+// See comment in BrowserMain, where sigaction is called.
+void SIGINTHandler(int signal) {
+  GracefulShutdownHandler(signal, SIGINT);
+}
+
+// See comment in BrowserMain, where sigaction is called.
+void SIGTERMHandler(int signal) {
+  GracefulShutdownHandler(signal, SIGTERM);
+}
+
 // Sets the file descriptor soft limit to |max_descriptors| or the OS hard
 // limit, whichever is lower.
 void SetFileDescriptorLimit(unsigned int max_descriptors) {
   struct rlimit limits;
   if (getrlimit(RLIMIT_NOFILE, &limits) == 0) {
     unsigned int new_limit = max_descriptors;
     if (limits.rlim_max > 0 && limits.rlim_max < max_descriptors) {
       new_limit = limits.rlim_max;
     }
     limits.rlim_cur = new_limit;
@@ skipping 64 matching lines @@
   memset(&action, 0, sizeof(action));
   action.sa_handler = SIGCHLDHandler;
   CHECK(sigaction(SIGCHLD, &action, NULL) == 0);
 
   // We need to handle SIGTERM, because that is how many POSIX-based distros ask
   // processes to quit gracefully at shutdown time.
   struct sigaction term_action;
   memset(&term_action, 0, sizeof(term_action));
   term_action.sa_handler = SIGTERMHandler;
   CHECK(sigaction(SIGTERM, &term_action, NULL) == 0);
+  // 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.
+  CHECK(sigaction(SIGINT, &term_action, NULL) == 0);
+  // And SIGHUP, for when the terminal disappears. On shutdown, many Linux
+  // distros send SIGHUP, SIGTERM, and then SIGKILL.
+  CHECK(sigaction(SIGHUP, &term_action, NULL) == 0);
 
   const std::wstring fd_limit_string =
       parsed_command_line.GetSwitchValue(switches::kFileDescriptorLimit);
   int fd_limit = 0;
   if (!fd_limit_string.empty()) {
     StringToInt(WideToUTF16Hack(fd_limit_string), &fd_limit);
   }
 #if defined(OS_MACOSX)
   // We use quite a few file descriptors for our IPC, and the default limit on
   // the Mac is low (256), so bump it up if there is no explicit override.
@@ skipping 597 matching lines @@
   if (metrics)
     metrics->Stop();
 
   // browser_shutdown takes care of deleting browser_process, so we need to
   // release it.
   browser_process.release();
   browser_shutdown::Shutdown();
 
   return result_code;
 }