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

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"
 
 #ifdef OS_MACOSX
 #include <CoreFoundation/CFNumber.h>
 #include <IOKit/IOTypes.h>
@@ skipping 108 matching lines @@
     return new SyncerThreadTimedStop(command_channel, mgr, connection_manager,
         all_status, model_safe_worker);
   } else {
     // The default SyncerThread implementation, which does not time-out when
     // Stop is called.
     return new SyncerThread(command_channel, mgr, connection_manager,
         all_status, model_safe_worker);
   }
 }
 
-bool SyncerThread::NudgeSyncer(int milliseconds_from_now, NudgeSource source) {
+void SyncerThread::NudgeSyncer(int milliseconds_from_now, NudgeSource source) {
   AutoLock lock(lock_);
   if (vault_.syncer_ == NULL) {
-    return false;
+    return;
   }
+
+  if (vault_.current_wait_interval_.had_nudge_during_backoff) {
+    // Drop nudges on the floor if we've already had one since starting this
+    // stage of exponential backoff.
+    return;
+  }
+
   NudgeSyncImpl(milliseconds_from_now, source);
-  return true;
 }
 
 SyncerThread::SyncerThread()
     : thread_main_started_(false, false),
       thread_("SyncEngine_SyncerThread"),
       vault_field_changed_(&lock_),
       p2p_authenticated_(false),
       p2p_subscribed_(false),
       client_command_hookup_(NULL),
       conn_mgr_hookup_(NULL),
@@ skipping 150 matching lines @@
     syncer_long_poll_interval_seconds_ = event->set_sync_long_poll_interval();
   }
 }
 
 void SyncerThread::ThreadMainLoop() {
   // This is called with lock_ acquired.
   lock_.AssertAcquired();
   LOG(INFO) << "In thread main loop.";
 
   // Use the short poll value by default.
-  TimeDelta poll_seconds =
+  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;
 
   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;
     }
 
     if (vault_.syncer_ == NULL) {
       LOG(INFO) << "Syncer thread waiting for database initialization.";
       while (vault_.syncer_ == NULL && !vault_.stop_syncer_thread_)
         vault_field_changed_.Wait();
       LOG_IF(INFO, !(vault_.syncer_ == NULL))
           << "Syncer was found after DB started.";
       continue;
     }
 
-    const TimeTicks next_poll = last_sync_time + poll_seconds;
+    const TimeTicks next_poll = last_sync_time +
+        vault_.current_wait_interval_.poll_delta;
     const TimeTicks end_wait =
         !vault_.nudge_queue_.empty() &&
         vault_.nudge_queue_.top().first < next_poll ?
         vault_.nudge_queue_.top().first : next_poll;
     LOG(INFO) << "end_wait is " << end_wait.ToInternalValue();
     LOG(INFO) << "next_poll is " << next_poll.ToInternalValue();
 
     // We block until the CV is signaled (e.g a control field changed, loss of
     // network connection, nudge, spurious, etc), or the poll interval elapses.
     TimeDelta sleep_time = end_wait - TimeTicks::Now();
     if (sleep_time > TimeDelta::FromSeconds(0)) {
       vault_field_changed_.TimedWait(sleep_time);
 
       if (TimeTicks::Now() < end_wait) {
         // Didn't timeout. Could be a spurious signal, or a signal corresponding
         // to an actual change in one of our control fields.  By continuing here
         // we perform the typical "always recheck conditions when signaled",
         // (typically handled by a while(condition_not_met) cv.wait() construct)
         // because we jump to the top of the loop.  The main difference is we
         // recalculate the wait interval, but last_sync_time won't have changed.
         // So if we were signaled by a nudge (for ex.) we'll grab the new nudge
         // off the queue and wait for that delta.  If it was a spurious signal,
         // we'll keep waiting for the same moment in time as we just were.
         continue;
        }
     }
 
     // Handle a nudge, caused by either a notification or a local bookmark
     // event.  This will also update the source of the following SyncMain call.
-    UpdateNudgeSource(&continue_sync_cycle, &initial_sync_for_thread);
+    bool nudged = UpdateNudgeSource(continue_sync_cycle,
+                                    &initial_sync_for_thread);
 
     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";
-    poll_seconds = TimeDelta::FromSeconds(CalculatePollingWaitTime(
-        allstatus_->status(), static_cast<int>(poll_seconds.InSeconds()),
-        &user_idle_milliseconds, &continue_sync_cycle));
+    vault_.current_wait_interval_ = CalculatePollingWaitTime(
+        allstatus_->status(),
+        static_cast<int>(vault_.current_wait_interval_.poll_delta.InSeconds()),
+        &user_idle_milliseconds, &continue_sync_cycle, nudged);
   }
-
 }
 
 // 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).
-int SyncerThread::CalculatePollingWaitTime(
+SyncerThread::WaitInterval SyncerThread::CalculatePollingWaitTime(
     const AllStatus::Status& status,
     int last_poll_wait,  // Time in seconds.
     int* user_idle_milliseconds,
-    bool* continue_sync_cycle) {
+    bool* continue_sync_cycle,
+    bool was_nudged) {
+  lock_.AssertAcquired();  // We access 'vault' in here, so we need the lock.
+  WaitInterval return_interval;
   bool is_continuing_sync_cyle = *continue_sync_cycle;
   *continue_sync_cycle = false;
 
   // Determine if the syncer has unfinished work to do from allstatus_.
   const bool syncer_has_work_to_do =
     status.updates_available > status.updates_received
     || status.unsynced_count > 0;
   LOG(INFO) << "syncer_has_work_to_do is " << syncer_has_work_to_do;
 
   // First calculate the expected wait time, figuring in any backoff because of
   // user idle time.  next_wait is in seconds
   syncer_polling_interval_ = (!status.notifications_enabled) ?
       syncer_short_poll_interval_seconds_ :
       syncer_long_poll_interval_seconds_;
   int default_next_wait = syncer_polling_interval_;
-  int actual_next_wait = default_next_wait;
+  return_interval.poll_delta = TimeDelta::FromSeconds(default_next_wait);
 
   if (syncer_has_work_to_do) {
     // Provide exponential backoff due to consecutive errors, else attempt to
     // complete the work as soon as possible.
-    if (!is_continuing_sync_cyle) {
-      actual_next_wait = AllStatus::GetRecommendedDelaySeconds(0);
+    if (is_continuing_sync_cyle) {
+      return_interval.mode = WaitInterval::EXPONENTIAL_BACKOFF;
+      if (was_nudged && vault_.current_wait_interval_.mode ==
+          WaitInterval::EXPONENTIAL_BACKOFF) {
+          // We were nudged, it failed, and we were already in backoff.
+          return_interval.had_nudge_during_backoff = true;
+          // Keep exponent for exponential backoff the same in this case.
+          return_interval.poll_delta = vault_.current_wait_interval_.poll_delta;
+      } else {
+        // We weren't nudged, or we were in a NORMAL wait interval until now.
+        return_interval.poll_delta = TimeDelta::FromSeconds(
+            AllStatus::GetRecommendedDelaySeconds(last_poll_wait));
+      }
     } else {
-      actual_next_wait = AllStatus::GetRecommendedDelaySeconds(last_poll_wait);
+      // No consecutive error.
+      return_interval.poll_delta = TimeDelta::FromSeconds(
+           AllStatus::GetRecommendedDelaySeconds(0));
     }
     *continue_sync_cycle = true;
   } else if (!status.notifications_enabled) {
     // Ensure that we start exponential backoff from our base polling
     // interval when we are not continuing a sync cycle.
     last_poll_wait = std::max(last_poll_wait, syncer_polling_interval_);
 
     // Did the user start interacting with the computer again?
     // If so, revise our idle time (and probably next_sync_time) downwards
     int new_idle_time = disable_idle_detection_ ? 0 : UserIdleTime();
     if (new_idle_time < *user_idle_milliseconds) {
       *user_idle_milliseconds = new_idle_time;
     }
-    actual_next_wait = CalculateSyncWaitTime(last_poll_wait * 1000,
-                                              *user_idle_milliseconds) / 1000;
-    DCHECK_GE(actual_next_wait, default_next_wait);
+    return_interval.poll_delta = TimeDelta::FromMilliseconds(
+        CalculateSyncWaitTime(last_poll_wait * 1000,
+                              *user_idle_milliseconds));
+    DCHECK_GE(return_interval.poll_delta.InSeconds(), default_next_wait);
   }
 
   LOG(INFO) << "Sync wait: idle " << default_next_wait
-            << " non-idle or backoff " << actual_next_wait << ".";
+            << " non-idle or backoff "
+            << return_interval.poll_delta.InSeconds() << ".";
 
-  return actual_next_wait;
+  return return_interval;
 }
 
 void SyncerThread::ThreadMain() {
   AutoLock lock(lock_);
   // Signal Start() to let it know we've made it safely onto the message loop,
   // and unblock it's caller.
   thread_main_started_.Signal();
   ThreadMainLoop();
   LOG(INFO) << "Syncer thread ThreadMain is done.";
 }
 
 void SyncerThread::SyncMain(Syncer* syncer) {
   CHECK(syncer);
   AutoUnlock unlock(lock_);
   while (syncer->SyncShare()) {
     LOG(INFO) << "Looping in sync share";
   }
   LOG(INFO) << "Done looping in sync share";
 }
 
-void SyncerThread::UpdateNudgeSource(bool* continue_sync_cycle,
+bool SyncerThread::UpdateNudgeSource(bool continue_sync_cycle,
                                      bool* initial_sync) {
   bool nudged = false;
   NudgeSource nudge_source = kUnknown;
   // Has the previous sync cycle completed?
   if (continue_sync_cycle) {
     nudge_source = kContinuation;
   }
   // Update the nudge source if a new nudge has come through during the
   // previous sync cycle.
   while (!vault_.nudge_queue_.empty() &&
          TimeTicks::Now() >= vault_.nudge_queue_.top().first) {
     if (!nudged) {
       nudge_source = vault_.nudge_queue_.top().second;
-      *continue_sync_cycle = false;  //  Reset the continuation token on nudge.
       nudged = true;
     }
     vault_.nudge_queue_.pop();
   }
   SetUpdatesSource(nudged, nudge_source, initial_sync);
+  return nudged;
 }
 
 void SyncerThread::SetUpdatesSource(bool nudged, NudgeSource nudge_source,
                                     bool* initial_sync) {
   sync_pb::GetUpdatesCallerInfo::GET_UPDATES_SOURCE updates_source =
       sync_pb::GetUpdatesCallerInfo::UNKNOWN;
   if (*initial_sync) {
     updates_source = sync_pb::GetUpdatesCallerInfo::FIRST_UPDATE;
     *initial_sync = false;
   } else if (!nudged) {
@@ skipping 154 matching lines @@
       break;
   }
 
   if (NULL != vault_.syncer_) {
     vault_.syncer_->set_notifications_enabled(
         p2p_authenticated_ && p2p_subscribed_);
   }
 }
 
 }  // namespace browser_sync