Iplement the idle timer for Linux using libxss.

base/idle_timer.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/idle_timer.h"
 
 #if defined(OS_MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #endif
 
+#if defined(OS_LINUX) && 0

[Evan Martin, 2008/11/06 20:28:19]

Perhaps rather than the 0, just make up a define like "DISABLE_XSS_SUPPORT" and
test that.  Then define it just above here and put the comment about twiddling
it to enable the support above it.

+// We may not want to port idle_timer to Linux, but we have implemented it
+// anyway.  Remove the 0 above if we want it.
+#include <gdk/gdkx.h>
+#include <X11/extensions/scrnsaver.h>
+#include "base/lazy_instance.h"
+#include "base/thread_local.h"
+#endif
+
 #include "base/message_loop.h"
 #include "base/time.h"
 
 namespace base {
 
 #if defined(OS_WIN)
 bool OSIdleTimeSource(int32 *milliseconds_interval_since_last_event) {
   LASTINPUTINFO lastInputInfo;
   lastInputInfo.cbSize = sizeof(lastInputInfo);
   if (GetLastInputInfo(&lastInputInfo) == 0) {
@@ skipping 12 matching lines @@
   return true;
 }
 #elif defined(OS_MACOSX)
 bool OSIdleTimeSource(int32 *milliseconds_interval_since_last_event) {
   *milliseconds_interval_since_last_event = 
       CGEventSourceSecondsSinceLastEventType(
           kCGEventSourceStateCombinedSessionState, 
           kCGAnyInputEventType) * 1000.0;
   return true;
 }
+#elif defined(OS_LINUX) && 0
+// We may not want to port idle_timer to Linux, but we have implemented it
+// anyway.  Remove the 0 above if we want it.
+
+struct IdleState {
+  bool have_screen_saver;
+  ThreadLocalPointer<XScreenSaverInfo*> screen_saver_info;
+};
+
+struct IdleStateLazyInstanceTraits {
+  static void New(void* instance) {

[Dean McNamee, 2008/11/06 08:57:05]

This code is not technically correct.  You never construct (or destroy)
IdleState.  Look at other examples of how to use the LazyInstance traits.  I
realize it's ok here, because LazyInstance preallocates the space, and it will
be initialized to 0, however, it is not designed to be used like that.  You have
to use placement new...

However, you control the struct completely.  So it is best not to use traits at
all (I encourage avoiding traits for a lot of reasons).  Move the New() to be
the IdleState() constructor, and Delete() to be it's destructor.

+    IdleState* state = static_cast<IdleState*>(instance);
+    int event_base, error_base;
+    state->have_screen_saver = XScreenSaverQueryExtension(
+        GDK_DISPLAY(), &event_base, &error_base);
+    if (state->have_screen_saver)
+      *state->screen_saver_info.Get() = XScreenSaverAllocInfo();
+  }
+  static void Delete(void* instance) {
+    IdleState* state = static_cast<IdleState*>(instance);
+    if (*state->screen_saver_info.Get()) {
+      XFree(*state->screen_saver_info.Get());
+      state->screen_saver_info.~ThreadLocalPointer();
+    }
+  }
+};
+
+bool OSIdleTimeSource(int32* milliseconds_interval_since_last_event) {
+  static LazyInstance<IdleState, IdleStateLazyInstanceTraits> state_instance(
+      base::LINKER_INITIALIZED);
+  IdleState* state = state_instance.Pointer();
+  if (state->have_screen_saver && state->screen_saver_info.Get()) {
+    XScreenSaverQueryInfo(GDK_DISPLAY(), GDK_ROOT_WINDOW(),
+                          *state->screen_saver_info.Get());
+    *milliseconds_interval_since_last_event =
+        (*state->screen_saver_info.Get())->idle;
+    return true;
+  }
+  return false;
+}
 #endif
 
 IdleTimer::IdleTimer(TimeDelta idle_time, bool repeat)
     : idle_interval_(idle_time),
       repeat_(repeat),
       idle_time_source_(OSIdleTimeSource) {
   DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type()) <<
       "Requires a thread that processes Windows UI events";
 }
 
@@ skipping 41 matching lines @@
   TimeDelta current_idle_time = CurrentIdleTime();
   if (current_idle_time > time_since_last_fire) {
     if (repeat_)
       return idle_interval_ - time_since_last_fire;
     return idle_interval_;
   }
   return idle_interval_ - current_idle_time;
 }
 
 }  // namespace base