Adding a SIGTERM handler for OS_POSIX builds.

chrome/browser/browser_uitest.cc

 // Copyright (c) 2006-2008 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 "base/file_path.h"
 #include "base/gfx/native_widget_types.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/platform_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request_unittest.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
+// Delay to let the browser shut down before trying more brutal methods.
+static const int kWaitForTerminateMsec = 30000;
+
 class BrowserTest : public UITest {
+
+ protected:
+  void TerminateBrowser() {
+#if defined(OS_WIN)
+    scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
+    ASSERT_TRUE(browser->TerminateSession());
+#elif defined(OS_POSIX)
+    // There's nothing to do here if the browser is not running.
+    if (IsBrowserRunning()) {
+      automation()->SetFilteredInet(false);
+
+      int window_count = 0;
+      EXPECT_TRUE(automation()->GetBrowserWindowCount(&window_count));
+
+      // Now, drop the automation IPC channel so that the automation provider in
+      // the browser notices and drops its reference to the browser process.
+      automation()->Disconnect();
+
+      EXPECT_EQ(kill(process_, SIGTERM), 0);
+
+      // Wait for the browser process to quit. It should have quit when it got
+      // SIGTERM.
+      int timeout = kWaitForTerminateMsec;
+#ifdef WAIT_FOR_DEBUGGER_ON_OPEN
+      timeout = 500000;
+#endif
+      if (!base::WaitForSingleProcess(process_, timeout)) {
+        // We need to force the browser to quit because it didn't quit fast
+        // enough. Take no chance and kill every chrome processes.
+        CleanupAppProcesses();
+      }
+
+      // Don't forget to close the handle
+      base::CloseProcessHandle(process_);
+      process_ = NULL;
+    }
+#endif  // OS_POSIX
+  }
+
 };
 
 class VisibleBrowserTest : public UITest {
  protected:
   VisibleBrowserTest() : UITest() {
     show_window_ = true;
   }
 };
 
 #if defined(OS_WIN)
 // The browser should quit quickly if it receives a WM_ENDSESSION message.
 TEST_F(BrowserTest, WindowsSessionEnd) {
+#elif defined(OS_POSIX)
+// The browser should quit gracefully and quickly if it receives a SIGTERM.
+TEST_F(BrowserTest, PosixSessionEnd) {
+#endif
+#if defined(OS_WIN) || defined(OS_POSIX)
   FilePath test_file(test_data_directory_);
   test_file = test_file.AppendASCII("title1.html");
 
   NavigateToURL(net::FilePathToFileURL(test_file));
   PlatformThread::Sleep(action_timeout_ms());
 
-  scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
-  ASSERT_TRUE(browser->TerminateSession());
+  TerminateBrowser();
 
   PlatformThread::Sleep(action_timeout_ms());
   ASSERT_FALSE(IsBrowserRunning());
 
   // Make sure the UMA metrics say we didn't crash.
   scoped_ptr<DictionaryValue> local_prefs(GetLocalState());
   bool exited_cleanly;
   ASSERT_TRUE(local_prefs.get());
   ASSERT_TRUE(local_prefs->GetBoolean(prefs::kStabilityExitedCleanly,
                                       &exited_cleanly));
   ASSERT_TRUE(exited_cleanly);
 
   // And that session end was successful.
   bool session_end_completed;
   ASSERT_TRUE(local_prefs->GetBoolean(prefs::kStabilitySessionEndCompleted,
                                       &session_end_completed));
   ASSERT_TRUE(session_end_completed);
 
   // Make sure session restore says we didn't crash.
   scoped_ptr<DictionaryValue> profile_prefs(GetDefaultProfilePreferences());
   ASSERT_TRUE(profile_prefs.get());
   ASSERT_TRUE(profile_prefs->GetBoolean(prefs::kSessionExitedCleanly,
                                         &exited_cleanly));
   ASSERT_TRUE(exited_cleanly);
 }
-#endif
+#endif  // OS_WIN || OS_POSIX
 
 // Test that scripts can fork a new renderer process for a tab in a particular
 // case (which matches following a link in Gmail).  The script must open a new
 // tab, set its window.opener to null, and redirect it to a cross-site URL.
 // (Bug 1115708)
 // This test can only run if V8 is in use, and not KJS, because KJS will not
 // set window.opener to null properly.
 #ifdef CHROME_V8
 TEST_F(BrowserTest, NullOpenerRedirectForksProcess) {
   // This test only works in multi-process mode
@@ skipping 153 matching lines @@
 
   GURL url = net::FilePathToFileURL(test_file);
   ASSERT_TRUE(tab->NavigateToURL(url));
 
   std::string value = WaitUntilCookieNonEmpty(tab.get(), url,
         "status", kTestIntervalMs, kTestWaitTimeoutMs);
   ASSERT_STREQ("Disallowed", value.c_str());
 }
 
 }  // namespace