For sync exponential backoff, allow one nudge per exponential backoff interva...

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_
 
@@ skipping 56 matching lines @@
 };
 
 class SyncerThread : public base::RefCountedThreadSafe<SyncerThread> {
   FRIEND_TEST(SyncerThreadTest, CalculateSyncWaitTime);
   FRIEND_TEST(SyncerThreadTest, CalculatePollingWaitTime);
   FRIEND_TEST(SyncerThreadWithSyncerTest, Polling);
   FRIEND_TEST(SyncerThreadWithSyncerTest, Nudge);
   friend class SyncerThreadWithSyncerTest;
   friend class SyncerThreadFactory;
 public:
+  // Encapsulates the parameters that make up an interval on which the
+  // syncer thread is sleeping.
+  struct WaitInterval {
+    enum Mode {
+      // A wait interval whose duration has not been affected by exponential
+      // backoff.  The base case for exponential backoff falls in to this case
+      // (e.g when the exponent is 1).  So far, we don't need a separate case.
+      // NORMAL intervals are not nudge-rate limited.
+      NORMAL,
+      // A wait interval whose duration has been affected by exponential
+      // backoff.
+      // EXPONENTIAL_BACKOFF intervals are nudge-rate limited to 1 per interval.
+      EXPONENTIAL_BACKOFF,
+    };
+
+    Mode mode;
+    // This bool is set to true if we have observed a nudge during during this
+    // interval and mode == EXPONENTIAL_BACKOFF.
+    bool had_nudge_during_backoff;
+    base::TimeDelta poll_delta;  // The wait duration until the next poll.
+
+    WaitInterval() : mode(NORMAL), had_nudge_during_backoff(false) { }
+  };
+
   enum NudgeSource {
     kUnknown = 0,
     kNotification,
     kLocal,
     kContinuation
   };
   // Server can overwrite these values via client commands.
   // Standard short poll. This is used when XMPP is off.
   static const int kDefaultShortPollIntervalSeconds = 60;
   // Long poll is used when XMPP is on.
   static const int kDefaultLongPollIntervalSeconds = 3600;
   // 30 minutes by default. If exponential backoff kicks in, this is the
   // longest possible poll interval.
   static const int kDefaultMaxPollIntervalMs = 30 * 60 * 1000;
 
   virtual ~SyncerThread();
 
   virtual void WatchConnectionManager(ServerConnectionManager* conn_mgr);
 
   // Starts a syncer thread.
   // Returns true if it creates a thread or if there's currently a thread
   // running and false otherwise.
   virtual bool Start();
 
   // Stop processing. |max_wait| doesn't do anything in this version.
   virtual bool Stop(int max_wait);
 
   // Nudges the syncer to sync with a delay specified. This API is for access
   // from the SyncerThread's controller and will cause a mutex lock.
-  virtual bool NudgeSyncer(int milliseconds_from_now, NudgeSource source);
+  virtual void NudgeSyncer(int milliseconds_from_now, NudgeSource source);
 
   // Registers this thread to watch talk mediator events.
   virtual void WatchTalkMediator(TalkMediator* talk_mediator);
 
   virtual void WatchClientCommands(ClientCommandChannel* channel);
 
   virtual SyncerEventChannel* channel();
 
  protected:
   SyncerThread();  // Necessary for temporary pthreads-based PIMPL impl.
@@ skipping 48 matching lines @@
 
     Syncer* syncer_;
 
     // State of the server connection.
     bool connected_;
 
     // A queue of all scheduled nudges.  One insertion for every call to
     // NudgeQueue().
     NudgeQueue nudge_queue_;
 
+    // The wait interval for to the current iteration of our main loop.  This is
+    // only written to by the syncer thread, and since the only reader from a
+    // different thread (NudgeSync) is called at totally random times, we don't
+    // really need to access mutually exclusively as the data races that exist
+    // are intrinsic, but do so anyway and avoid using 'volatile'.
+    WaitInterval current_wait_interval_;
+
     ProtectedFields()
         : stop_syncer_thread_(false), syncer_(NULL), connected_(false) {}
   } vault_;
 
   // Gets signaled whenever a thread outside of the syncer thread changes a
   // protected field in the vault_.
   ConditionVariable vault_field_changed_;
 
   // Used to lock everything in |vault_|.
   Lock lock_;
 
  private:
-  // A few members to gate the rate at which we nudge the syncer.
-  enum {
-    kNudgeRateLimitCount = 6,
-    kNudgeRateLimitTime = 180,
-  };
-
   // Threshold multipler for how long before user should be considered idle.
   static const int kPollBackoffThresholdMultiplier = 10;
 
   friend void* RunSyncerThread(void* syncer_thread);
   void* Run();
   void HandleDirectoryManagerEvent(
       const syncable::DirectoryManagerEvent& event);
   void HandleSyncerEvent(const SyncerEvent& event);
   void HandleClientCommand(ClientCommandChannel::EventType event);
 
   void HandleServerConnectionEvent(const ServerConnectionEvent& event);
 
   void HandleTalkMediatorEvent(const TalkMediatorEvent& event);
 
   void SyncMain(Syncer* syncer);
 
-  // Calculates the next sync wait time in seconds.  last_poll_wait is the time
-  // duration of the previous polling timeout which was used.
-  // user_idle_milliseconds is updated by this method, and is a report of the
-  // full amount of time since the last period of activity for the user.  The
-  // continue_sync_cycle parameter is used to determine whether or not we are
-  // calculating a polling wait time that is a continuation of an sync cycle
-  // which terminated while the syncer still had work to do.
-  virtual int CalculatePollingWaitTime(
+  // Calculates the next sync wait time and exponential backoff state.
+  // last_poll_wait is the time duration of the previous polling timeout which
+  // was used. user_idle_milliseconds is updated by this method, and is a report
+  // of the full amount of time since the last period of activity for the user.
+  // The continue_sync_cycle parameter is used to determine whether or not we
+  // are calculating a polling wait time that is a continuation of an sync cycle
+  // which terminated while the syncer still had work to do. was_nudged is used
+  // in case of exponential backoff so we only allow one nudge per backoff
+  // interval.
+  WaitInterval CalculatePollingWaitTime(
       const AllStatus::Status& status,
       int last_poll_wait,  // in s
       int* user_idle_milliseconds,
-      bool* continue_sync_cycle);
+      bool* continue_sync_cycle,
+      bool was_nudged);
+
   // Helper to above function, considers effect of user idle time.
   virtual int CalculateSyncWaitTime(int last_wait, int user_idle_ms);
 
   // Sets the source value of the controlled syncer's updates_source value.
   // The initial sync boolean is updated if read as a sentinel.  The following
-  // two methods work in concert to achieve this goal.
-  void UpdateNudgeSource(bool* continue_sync_cycle,
+  // two methods work in concert to achieve this goal.  Returns true if it
+  // determines a nudge actually occurred.
+  bool UpdateNudgeSource(bool continue_sync_cycle,
                          bool* initial_sync);
   void SetUpdatesSource(bool nudged, NudgeSource nudge_source,
                         bool* initial_sync);
 
   // 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_;
@@ skipping 38 matching lines @@
 
   // Useful for unit tests
   bool disable_idle_detection_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerThread);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_