Add support for UserIdleTime to Linux.

chrome/browser/sync/engine/syncer_thread.cc

 // Copyright (c) 2009 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 "chrome/browser/sync/engine/syncer_thread.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CFNumber.h>
 #include <IOKit/IOTypes.h>
@@ skipping 13 matching lines @@
 #include "chrome/browser/sync/notifier/listener/talk_mediator_impl.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/common/chrome_switches.h"
 
 using std::priority_queue;
 using std::min;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
-namespace {
-
-// Returns the amount of time since the user last interacted with the computer,
-// in milliseconds
-int UserIdleTime() {
-#if defined(OS_WIN)
-  LASTINPUTINFO last_input_info;
-  last_input_info.cbSize = sizeof(LASTINPUTINFO);
-
-  // Get time in windows ticks since system start of last activity.
-  BOOL b = ::GetLastInputInfo(&last_input_info);
-  if (b == TRUE)
-    return ::GetTickCount() - last_input_info.dwTime;
-#elif defined(OS_MACOSX)
-  // It would be great to do something like:
-  //
-  // return 1000 *
-  //     CGEventSourceSecondsSinceLastEventType(
-  //         kCGEventSourceStateCombinedSessionState,
-  //         kCGAnyInputEventType);
-  //
-  // Unfortunately, CGEvent* lives in ApplicationServices, and we're a daemon
-  // and can't link that high up the food chain. Thus this mucking in IOKit.
-
-  io_service_t hid_service =
-      IOServiceGetMatchingService(kIOMasterPortDefault,
-                                  IOServiceMatching("IOHIDSystem"));
-  if (!hid_service) {
-    LOG(WARNING) << "Could not obtain IOHIDSystem";
-    return 0;
-  }
-
-  CFTypeRef object = IORegistryEntryCreateCFProperty(hid_service,
-                                                     CFSTR("HIDIdleTime"),
-                                                     kCFAllocatorDefault,
-                                                     0);
-  if (!object) {
-    LOG(WARNING) << "Could not get IOHIDSystem's HIDIdleTime property";
-    IOObjectRelease(hid_service);
-    return 0;
-  }
-
-  int64 idle_time;  // in nanoseconds
-  Boolean success = false;
-  if (CFGetTypeID(object) == CFNumberGetTypeID()) {
-    success = CFNumberGetValue((CFNumberRef)object,
-                               kCFNumberSInt64Type,
-                               &idle_time);
-  } else {
-    LOG(WARNING) << "IOHIDSystem's HIDIdleTime property isn't a number!";
-  }
-
-  CFRelease(object);
-  IOObjectRelease(hid_service);
-
-  if (!success) {
-    LOG(WARNING) << "Could not get IOHIDSystem's HIDIdleTime property's value";
-    return 0;
-  } else {
-    return idle_time / 1000000;  // nano to milli
-  }
-#else
-  static bool was_logged = false;
-  if (!was_logged) {
-    was_logged = true;
-    LOG(INFO) << "UserIdleTime unimplemented on this platform, "
-        "synchronization will not throttle when user idle";
-  }
-#endif
-
-  return 0;
-}
-
-}  // namespace
 
 namespace browser_sync {
 
 const int SyncerThread::kDefaultShortPollIntervalSeconds = 60;
 const int SyncerThread::kDefaultLongPollIntervalSeconds = 3600;
 const int SyncerThread::kDefaultMaxPollIntervalMs = 30 * 60 * 1000;
 
 void SyncerThread::NudgeSyncer(int milliseconds_from_now, NudgeSource source) {
   AutoLock lock(lock_);
   if (vault_.syncer_ == NULL) {
@@ skipping 135 matching lines @@
   LOG(INFO) << "In thread main loop.";
 
   // Use the short poll value by default.
   vault_.current_wait_interval_.poll_delta =
       TimeDelta::FromSeconds(syncer_short_poll_interval_seconds_);
   int user_idle_milliseconds = 0;
   TimeTicks last_sync_time;
   bool initial_sync_for_thread = true;
   bool continue_sync_cycle = false;
 
+#if defined(OS_LINUX)
+  idle_query_.reset(new IdleQueryLinux());
+#endif
+
   while (!vault_.stop_syncer_thread_) {
     // The Wait()s in these conditionals using |vault_| are not TimedWait()s (as
     // below) because we cannot poll until these conditions are met, so we wait
     // indefinitely.
     if (!vault_.connected_) {
       LOG(INFO) << "Syncer thread waiting for connection.";
       while (!vault_.connected_ && !vault_.stop_syncer_thread_)
         vault_field_changed_.Wait();
       LOG_IF(INFO, vault_.connected_) << "Syncer thread found connection.";
       continue;
@@ skipping 49 matching lines @@
     LOG(INFO) << "Calling Sync Main at time " << Time::Now().ToInternalValue();
     SyncMain(vault_.syncer_);
     last_sync_time = TimeTicks::Now();
 
     LOG(INFO) << "Updating the next polling time after SyncMain";
     vault_.current_wait_interval_ = CalculatePollingWaitTime(
         allstatus_->status(),
         static_cast<int>(vault_.current_wait_interval_.poll_delta.InSeconds()),
         &user_idle_milliseconds, &continue_sync_cycle, nudged);
   }
+#if defined(OS_LINUX)
+  idle_query_.reset();
+#endif
 }
 
 // We check how long the user's been idle and sync less often if the machine is
 // not in use. The aim is to reduce server load.
 // TODO(timsteele): Should use Time(Delta).
 SyncerThread::WaitInterval SyncerThread::CalculatePollingWaitTime(
     const AllStatus::Status& status,
     int last_poll_wait,  // Time in seconds.
     int* user_idle_milliseconds,
     bool* continue_sync_cycle,
@@ skipping 288 matching lines @@
       }
       break;
     default:
       break;
   }
 
   session_context_->set_notifications_enabled(p2p_authenticated_ &&
                                               p2p_subscribed_);
 }
 
+// Returns the amount of time since the user last interacted with the computer,
+// in milliseconds
+int SyncerThread::UserIdleTime() {
+#if defined(OS_WIN)
+  LASTINPUTINFO last_input_info;
+  last_input_info.cbSize = sizeof(LASTINPUTINFO);
+
+  // Get time in windows ticks since system start of last activity.
+  BOOL b = ::GetLastInputInfo(&last_input_info);
+  if (b == TRUE)
+    return ::GetTickCount() - last_input_info.dwTime;
+#elif defined(OS_MACOSX)
+  // It would be great to do something like:
+  //
+  // return 1000 *
+  //     CGEventSourceSecondsSinceLastEventType(
+  //         kCGEventSourceStateCombinedSessionState,
+  //         kCGAnyInputEventType);
+  //
+  // Unfortunately, CGEvent* lives in ApplicationServices, and we're a daemon
+  // and can't link that high up the food chain. Thus this mucking in IOKit.
+
+  io_service_t hid_service =
+      IOServiceGetMatchingService(kIOMasterPortDefault,
+                                  IOServiceMatching("IOHIDSystem"));
+  if (!hid_service) {
+    LOG(WARNING) << "Could not obtain IOHIDSystem";
+    return 0;
+  }
+
+  CFTypeRef object = IORegistryEntryCreateCFProperty(hid_service,
+                                                     CFSTR("HIDIdleTime"),
+                                                     kCFAllocatorDefault,
+                                                     0);
+  if (!object) {
+    LOG(WARNING) << "Could not get IOHIDSystem's HIDIdleTime property";
+    IOObjectRelease(hid_service);
+    return 0;
+  }
+
+  int64 idle_time;  // in nanoseconds
+  Boolean success = false;
+  if (CFGetTypeID(object) == CFNumberGetTypeID()) {
+    success = CFNumberGetValue((CFNumberRef)object,
+                               kCFNumberSInt64Type,
+                               &idle_time);
+  } else {
+    LOG(WARNING) << "IOHIDSystem's HIDIdleTime property isn't a number!";
+  }
+
+  CFRelease(object);
+  IOObjectRelease(hid_service);
+
+  if (!success) {
+    LOG(WARNING) << "Could not get IOHIDSystem's HIDIdleTime property's value";
+    return 0;
+  } else {
+    return idle_time / 1000000;  // nano to milli
+  }
+#elif defined(OS_LINUX)
+  if (idle_query_.get()) {
+    return idle_query_->IdleTime();
+  } else {
+    return 0;
+  }
+#else
+  static bool was_logged = false;
+  if (!was_logged) {
+    was_logged = true;
+    LOG(INFO) << "UserIdleTime unimplemented on this platform, "
+        "synchronization will not throttle when user idle";
+  }
+#endif
+
+  return 0;
+}
+
+
 }  // namespace browser_sync