Fix leak of ShutdownDetector.

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/hi_res_timer_manager.h"
 #include "app/l10n_util.h"
@@ skipping 153 matching lines @@
   MessageLoopForUI::current()->Run();
 #endif
 }
 
 #if defined(OS_POSIX)
 // See comment in BrowserMain, where sigaction is called.
 void SIGCHLDHandler(int signal) {
 }
 
 int g_shutdown_pipe_write_fd = -1;
-int g_shutdown_pipe_read_fd = -1;
 
 // Common code between SIG{HUP, INT, TERM}Handler.
 void GracefulShutdownHandler(int signal) {
   // Reinstall the default handler.  We had one shot at graceful shutdown.
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   action.sa_handler = SIG_DFL;
   CHECK(sigaction(signal, &action, NULL) == 0);
 
   RAW_CHECK(g_shutdown_pipe_write_fd != -1);
-  RAW_CHECK(g_shutdown_pipe_read_fd != -1);
   size_t bytes_written = 0;
   do {
     int rv = HANDLE_EINTR(
         write(g_shutdown_pipe_write_fd,
               reinterpret_cast<const char*>(&signal) + bytes_written,
               sizeof(signal) - bytes_written));
     RAW_CHECK(rv >= 0);
     bytes_written += rv;
   } while (bytes_written < sizeof(signal));
 
@@ skipping 45 matching lines @@
   ssize_t ret;
   do {
     ret = HANDLE_EINTR(
         read(shutdown_fd_,
              reinterpret_cast<char*>(&signal) + bytes_read,
              sizeof(signal) - bytes_read));
     if (ret < 0) {
       NOTREACHED() << "Unexpected error: " << strerror(errno);
       break;
     } else if (ret == 0) {
-      NOTREACHED() << "Unexpected closure of shutdown pipe.";
+      // Normal shutdown.
       break;
     }
     bytes_read += ret;
   } while (bytes_read < sizeof(signal));
 
-  LOG(INFO) << "Handling shutdown for signal " << signal << ".";
+  if (bytes_read == sizeof(signal)) {
+    LOG(INFO) << "Handling shutdown for signal " << signal << ".";
 
-  if (!ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
-      NewRunnableFunction(BrowserList::CloseAllBrowsersAndExit))) {
-    // 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);
+    if (!ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableFunction(BrowserList::CloseAllBrowsersAndExit))) {
+      // 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.";
+      PLOG_IF(ERROR, raise(signal) != 0) << "Failed to raise signal";
 
-    // The signal may be handled on another thread.  Give that a chance to
-    // happen.
-    sleep(3);
+      // 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));
+      // 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));
+    }
   }
+
+  delete this;
 }
 
 // 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;
@@ skipping 123 matching lines @@
   const char* thread_name = thread_name_string.c_str();
   PlatformThread::SetName(thread_name);
   main_message_loop.set_thread_name(thread_name);
 
   // Register the main thread by instantiating it, but don't call any methods.
   ChromeThread main_thread(ChromeThread::UI, MessageLoop::current());
 
 #if defined(OS_POSIX)
   int pipefd[2];
   int ret = pipe(pipefd);
+  PlatformThreadHandle shutdown_detector_thread;
   if (ret < 0) {
     PLOG(DFATAL) << "Failed to create pipe";
   } else {
-    g_shutdown_pipe_read_fd = pipefd[0];
-    g_shutdown_pipe_write_fd = pipefd[1];
     const size_t kShutdownDetectorThreadStackSize = 4096;
-    if (!PlatformThread::CreateNonJoinable(
+    if (PlatformThread::Create(
         kShutdownDetectorThreadStackSize,
-        new ShutdownDetector(g_shutdown_pipe_read_fd))) {
+        new ShutdownDetector(pipefd[0]),
+        &shutdown_detector_thread)) {
+      // Successfully spawned shutdown detector thread.
+      g_shutdown_pipe_write_fd = pipefd[1];
+    } else {
       LOG(DFATAL) << "Failed to create shutdown detector task.";
+      ret = HANDLE_EINTR(close(pipefd[0]));
+      PLOG_IF(ERROR, ret != 0) << "Failed to close shutdown read pipe";
+      ret = HANDLE_EINTR(close(pipefd[1]));
+      PLOG_IF(ERROR, ret != 0) << "Failed to close shutdown write pipe";
     }
   }
 #endif  // defined(OS_POSIX)
 
   FilePath user_data_dir;
 #if defined(OS_WIN)
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 #else
   // Getting the user data dir can fail if the directory isn't
   // creatable, for example; on Windows in code below we bring up a
@@ skipping 513 matching lines @@
                            &result_code)) {
       // Call Recycle() here as late as possible, before going into the loop
       // because Start() will add things to it while creating the main window.
       if (pool)
         pool->Recycle();
       RunUIMessageLoop(browser_process.get());
     }
   }
   chrome_browser_net_websocket_experiment::WebSocketExperimentRunner::Stop();
 
+#if defined(OS_POSIX)
+  // If we initialized the shutdown pipe, then close it.
+  if (g_shutdown_pipe_write_fd != -1) {
+    ret = HANDLE_EINTR(close(g_shutdown_pipe_write_fd));
+    g_shutdown_pipe_write_fd = -1;
+    PLOG_IF(ERROR, ret != 0) << "Failed to close";
+  }
+#endif // defined(OS_POSIX)
+
   process_singleton.Cleanup();
 
   Platform::DidEndMainMessageLoop();
 
   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;
 }