wm: Fix FD leak in watchdog when Chrome is hanging.

chrome_watchdog_test.cc

 // Copyright (c) 2010 The Chromium OS 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 <gflags/gflags.h>
 #include <gtest/gtest.h>
 
 #include "base/logging.h"
 #include "cros/chromeos_wm_ipc_enums.h"
 #include "window_manager/chrome_watchdog.h"
@@ skipping 17 matching lines @@
 TEST_F(ChromeWatchdogTest, Basic) {
   ChromeWatchdog* watchdog = wm_->chrome_watchdog_.get();
 
   const XWindow kRoot = xconn_->GetRootWindow();
   const XAtom kProtocolsAtom = xconn_->GetAtomOrDie("WM_PROTOCOLS");
   const XAtom kPingAtom = xconn_->GetAtomOrDie("_NET_WM_PING");
   const XAtom kPidAtom = xconn_->GetAtomOrDie("_NET_WM_PID");
   const XAtom kClientMachineAtom = xconn_->GetAtomOrDie("WM_CLIENT_MACHINE");
   const XAtom kCardinalAtom = xconn_->GetAtomOrDie("CARDINAL");
 
-  int kPid = 456;
-  int kTimestamp = 123;
-  int kTimeoutMs = 5000;
+  const int kPid = 456;
+  const int kTimestamp = 123;
+  const int kTimeoutMs = 5000;
+
+  // Make sure that we don't leak any timeouts, either when we get a response
+  // from Chrome or when a timeout fires (http://crosbug.com/10583).
+  const int kInitialNumTimeouts = event_loop_->num_timeouts();
 
   // We should fail if no windows have been mapped.
   EXPECT_FALSE(watchdog->SendPingToChrome(kTimestamp, kTimeoutMs));
 
   // Map a single non-Chrome window and check that we don't send a ping
   // message to it.
   XWindow non_chrome_xid = CreateSimpleWindow();
   AppendAtomToProperty(non_chrome_xid, kProtocolsAtom, kPingAtom);
   xconn_->SetIntProperty(non_chrome_xid, kPidAtom, kCardinalAtom, kPid);
   xconn_->SetStringProperty(non_chrome_xid, kClientMachineAtom, GetHostname());
@@ skipping 62 matching lines @@
   wm_->HandleEvent(&event);
   EXPECT_TRUE(watchdog->has_outstanding_ping());
 
   // We should cancel the ping if we get the proper response.
   xconn_->InitClientMessageEvent(&event, kRoot, kProtocolsAtom,
                                  kPingAtom, kTimestamp, toplevel_xid, 0, 0);
   wm_->HandleEvent(&event);
   EXPECT_FALSE(watchdog->has_outstanding_ping());
   EXPECT_EQ(-1, watchdog->timeout_id_);
   EXPECT_EQ(-1, watchdog->last_killed_pid_);
+  EXPECT_EQ(kInitialNumTimeouts, event_loop_->num_timeouts());
 
   // If the timeout is invoked after we send the ping, we should kill
   // Chrome (well, not really, since this is a test, but 'last_killed_pid_'
   // should be set, at least).
   EXPECT_TRUE(watchdog->SendPingToChrome(kTimestamp, kTimeoutMs));
   watchdog->HandleTimeout();
   EXPECT_FALSE(watchdog->has_outstanding_ping());
   EXPECT_EQ(-1, watchdog->timeout_id_);
   EXPECT_EQ(kPid, watchdog->last_killed_pid_);
+  EXPECT_EQ(kInitialNumTimeouts, event_loop_->num_timeouts());
 }
 
 }  // namespace window_manager
 
 int main(int argc, char** argv) {
   // Ensure that we don't really send signals to processes.
   window_manager::AutoReset<bool> flag_resetter(
       &FLAGS_kill_chrome_if_hanging, false);
   return window_manager::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }