Raise SIGKILL if cast_service doesn't Finalize() within timeout.

chromecast/browser/cast_browser_main_parts.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 "chromecast/browser/cast_browser_main_parts.h"
 
+#if !defined(OS_ANDROID)
 #include <signal.h>
 #include <sys/prctl.h>
+#endif
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/run_loop.h"
 #include "cc/base/switches.h"
 #include "chromecast/base/metrics/cast_metrics_helper.h"
 #include "chromecast/base/metrics/grouped_histogram.h"
@@ skipping 55 matching lines @@
     if (sigaction(kSignalsToRunClosure[i], &sa_new, &sa_old) == -1) {
       NOTREACHED();
     } else {
       DCHECK_EQ(sa_old.sa_handler, SIG_DFL);
     }
   }
 
   // Get the first signal to exit when the parent process dies.
   prctl(PR_SET_PDEATHSIG, kSignalsToRunClosure[0]);
 }
+
+const int kKillOnAlarmTimeoutSec = 5;  // 5 seconds
+
+void KillOnAlarm(int signum) {
+  LOG(ERROR) << "Got alarm signal for termination: " << signum;
+  raise(SIGKILL);
+}
+
+void RegisterKillOnAlarm(int timeout_seconds) {
+  struct sigaction sa_new;
+  memset(&sa_new, 0, sizeof(sa_new));
+  sa_new.sa_handler = KillOnAlarm;
+  sigfillset(&sa_new.sa_mask);
+  sa_new.sa_flags = SA_RESTART;
+
+  struct sigaction sa_old;
+  if (sigaction(SIGALRM, &sa_new, &sa_old) == -1) {
+    NOTREACHED();
+  } else {
+    DCHECK_EQ(sa_old.sa_handler, SIG_DFL);
+  }
+
+  if (alarm(timeout_seconds) > 0)
+    NOTREACHED() << "Previous alarm() was cancelled";
+}
+
+void DeregisterKillOnAlarm() {
+  // Explicitly cancel any outstanding alarm() calls.
+  alarm(0);
+
+  struct sigaction sa_new;
+  memset(&sa_new, 0, sizeof(sa_new));
+  sa_new.sa_handler = SIG_DFL;
+  sigfillset(&sa_new.sa_mask);
+  sa_new.sa_flags = SA_RESTART;
+
+  struct sigaction sa_old;
+  if (sigaction(SIGALRM, &sa_new, &sa_old) == -1) {
+    NOTREACHED();
+  } else {
+    DCHECK_EQ(sa_old.sa_handler, KillOnAlarm);
+  }
+}
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 
 namespace chromecast {
 namespace shell {
 
 namespace {
 
 struct DefaultCommandLineSwitch {
@@ skipping 166 matching lines @@
 
   // If parameters_.ui_task is not NULL, we are running browser tests.
   if (parameters_.ui_task) {
     base::MessageLoop* message_loop = base::MessageLoopForUI::current();
     message_loop->PostTask(FROM_HERE, *parameters_.ui_task);
     message_loop->PostTask(FROM_HERE, quit_closure);
   }
 
   run_loop.Run();
 
+  // Once the main loop has stopped running, we give the browser process a few
+  // seconds to stop cast service and finalize all resources. If a hang occurs
+  // and cast services refuse to terminate successfully, then we SIGKILL the
+  // current process to avoid indefinte hangs.
+  RegisterKillOnAlarm(kKillOnAlarmTimeoutSec);
+
   cast_browser_process_->cast_service()->Stop();
   return true;
 #endif
 }
 
 void CastBrowserMainParts::PostMainMessageLoopRun() {
 #if defined(OS_ANDROID)
   // Android does not use native main MessageLoop.
   NOTREACHED();
 #else
   cast_browser_process_->cast_service()->Finalize();
   cast_browser_process_->metrics_service_client()->Finalize();
   cast_browser_process_.reset();
+  DeregisterKillOnAlarm();

[byungchul, 2015/03/23 20:51:11]

Not sure if it is useful.

[maclellant, 2015/03/23 21:12:45]

It seems cleaner to me to remove any side effects once we are done. This alarm
is only meant to guard against hangs during tear down, so once we are done we
should remove everything and cancel the alarm so we don't randomly get a SIGKILL
later.

You are correct though that it doesn't really do anything useful if the process
is going to terminate soon anyways.

 #endif
 }
 
 }  // namespace shell
 }  // namespace chromecast