Add support for UserIdleTime to Linux.

chrome/browser/sync/engine/syncer_thread.h

 // 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.
 //
 // A class to run the syncer on a thread.
 // This is the default implementation of SyncerThread whose Stop implementation
 // does not support a timeout, but is greatly simplified.
 #ifndef CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_
 #define CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_
 
 #include <list>
 #include <map>
 #include <queue>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/condition_variable.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
 #include "chrome/browser/sync/engine/all_status.h"
+#if defined(OS_LINUX)
+#include "chrome/browser/sync/engine/idle_query_linux.h"
+#endif
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"  // For FRIEND_TEST
 
 class EventListenerHookup;
 
 namespace syncable {
 class DirectoryManager;
 struct DirectoryManagerEvent;
 }
@@ skipping 206 matching lines @@
   // If |was_throttled| was true, this still discards elapsed nudges, but we
   // treat the request as a periodic poll rather than a nudge from a source.
   // TODO(timsteele/code reviewer): The first poll after a throttle period
   // will appear as a periodic request.  Do we want to be more specific?
   // Returns true if it determines a nudge actually occurred.
   bool UpdateNudgeSource(bool was_throttled, bool continue_sync_cycle,
                          bool* initial_sync);
   void SetUpdatesSource(bool nudged, NudgeSource nudge_source,
                         bool* initial_sync);
 
+  int UserIdleTime();
+
   // For unit tests only.
   virtual void DisableIdleDetection() { disable_idle_detection_ = true; }
 
   // State of the notification framework is tracked by these values.
   bool p2p_authenticated_;
   bool p2p_subscribed_;
 
   scoped_ptr<EventListenerHookup> conn_mgr_hookup_;
   const AllStatus* allstatus_;
 
@@ skipping 13 matching lines @@
 
   // This causes syncer to start syncing ASAP. If the rate of requests is too
   // high the request will be silently dropped.  mutex_ should be held when
   // this is called.
   void NudgeSyncImpl(int milliseconds_from_now, NudgeSource source);
 
   scoped_ptr<EventListenerHookup> talk_mediator_hookup_;
   scoped_ptr<EventListenerHookup> directory_manager_hookup_;
   scoped_ptr<EventListenerHookup> syncer_events_;
 
+#if defined(OS_LINUX)
+  // On Linux, we need this information in order to query idle time.
+  scoped_ptr<IdleQueryLinux> idle_query_;
+#endif
+
   scoped_ptr<sessions::SyncSessionContext> session_context_;
 
   // Events from the Syncer's syncer_event_channel are first processed by the
   // SyncerThread and then get relayed onto this channel for consumers.
   // TODO(timsteele): Wow did this confused me. I had removed the channel from
   // here thinking there was only one, and then realized this relay was
   // happening. Is this strict event handling order needed?!
   scoped_ptr<SyncerEventChannel> syncer_event_relay_channel_;
 
   // Set whenever the server instructs us to stop sending it requests until
   // a specified time, and reset for each call to SyncShare. (Note that the
   // WaitInterval::THROTTLED contract is such that we don't call SyncShare at
   // all until the "silenced until" embargo expires.)
   base::TimeTicks silenced_until_;
 
   // Useful for unit tests
   bool disable_idle_detection_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerThread);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_