Fix off-by-one bug for the negative transition in XIdle::AddIdleTimeout, which

src/platform/power_manager/xidle.cc

 // Copyright (c) 2009 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 "power_manager/xidle.h"
 #include <inttypes.h>
 #include "base/logging.h"
 
 namespace power_manager {
 
 static inline int64 XSyncValueToInt64(XSyncValue value) {
   return (static_cast<int64>(XSyncValueHigh32(value)) << 32 |
           static_cast<int64>(XSyncValueLow32(value)));
 }
 
 static inline void XSyncInt64ToValue(XSyncValue* xvalue, int64 value) {
   XSyncIntsToValue(xvalue, value, value >> 32);
 }
 
 XIdle::XIdle()
     : idle_counter_(0),
-      min_timeout_(kint64max) {
+      min_timeout_(kint64max),
+      display_(NULL) {
 }
 
 XIdle::~XIdle() {
   ClearTimeouts();
-  if (display_)
-    XCloseDisplay(display_);
 }
 
-bool XIdle::Init() {
+bool XIdle::Init(Display* display) {
   int major_version, minor_version;
-  display_ = XOpenDisplay(NULL);
-  if (display_ &&
-      XSyncQueryExtension(display_, &event_base_, &error_base_) &&
+  CHECK(display);
+  display_ = display;
+  if (XSyncQueryExtension(display_, &event_base_, &error_base_) &&
       XSyncInitialize(display_, &major_version, &minor_version)) {
     XSyncSystemCounter* counters;
     int ncounters;
     counters = XSyncListSystemCounters(display_, &ncounters);
 
     if (counters) {
       for (int i = 0; i < ncounters; i++) {
         if (counters[i].name && strcmp(counters[i].name, "IDLETIME") == 0) {
           idle_counter_ = counters[i].counter;
           break;
         }
       }
       XSyncFreeSystemCounterList(counters);
     }
   }
   return idle_counter_ != 0;
 }
 
 bool XIdle::AddIdleTimeout(int64 idle_timeout_ms) {
   DCHECK_NE(idle_counter_, 0);
+  DCHECK_GT(idle_timeout_ms, 1);
 
   if (idle_timeout_ms < min_timeout_) {
     min_timeout_ = idle_timeout_ms;
-    XSyncAlarm alarm = CreateIdleAlarm(min_timeout_, XSyncNegativeTransition);
+    XSyncAlarm alarm = CreateIdleAlarm(min_timeout_ - 1,

[Daniel Erat, 2010/03/16 21:40:01]

it'd be good to add a comment here describing the race condition that's being
worked around

+                                       XSyncNegativeTransition);
     if (!alarm)
       return false;
     if (!alarms_.empty()) {
       XSyncDestroyAlarm(display_, alarms_.front());
       alarms_.pop_front();
     }
     alarms_.push_front(alarm);
   }
 
   XSyncAlarm alarm = CreateIdleAlarm(idle_timeout_ms, XSyncPositiveTransition);
@@ skipping 50 matching lines @@
                 XSyncCADelta;
   XSyncAlarmAttributes attr;
   attr.trigger.counter = idle_counter_;
   attr.trigger.test_type = test_type;
   XSyncInt64ToValue(&attr.trigger.wait_value, idle_timeout_ms);
   XSyncIntToValue(&attr.delta, 0);
   return XSyncCreateAlarm(display_, mask, &attr);
 }
 
 }  // namespace power_manager