Unplumb AllStatus from SyncerThread.

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>
 #include <IOKit/IOKitLib.h>
 #endif
 
 #include <algorithm>
 #include <map>
 #include <queue>
 
+#include "base/rand_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "chrome/browser/sync/engine/auth_watcher.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
+#include "chrome/browser/sync/sessions/session_state.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "jingle/notifier/listener/notification_constants.h"
 
 using std::priority_queue;
 using std::min;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
+namespace browser_sync {
 
-namespace browser_sync {
+using sessions::SyncSessionSnapshot;
 
 // We use high values here to ensure that failure to receive poll updates from
 // the server doesn't result in rapid-fire polling from the client due to low
 // local limits.
 const int SyncerThread::kDefaultShortPollIntervalSeconds = 3600 * 8;
 const int SyncerThread::kDefaultLongPollIntervalSeconds = 3600 * 12;
 
 // TODO(tim): This is used to regulate the short poll (when notifications are
 // disabled) based on user idle time.  If it is set to a smaller value than
 // the short poll interval, it basically does nothing; for now, this is what
 // we want and allows stronger control over the poll rate from the server. We
 // should probably re-visit this code later and figure out if user idle time
 // is really something we want and make sure it works, if it is.
 const int SyncerThread::kDefaultMaxPollIntervalMs = 30 * 60 * 1000;
 
+// Backoff interval randomization factor.
+static const int kBackoffRandomizationFactor = 2;
+
+const int SyncerThread::kMaxBackoffSeconds = 60 * 60 * 4;  // 4 hours.
+
 void SyncerThread::NudgeSyncer(int milliseconds_from_now, NudgeSource source) {
   AutoLock lock(lock_);
   if (vault_.syncer_ == NULL) {
     return;
   }
 
   NudgeSyncImpl(milliseconds_from_now, source);
 }
 
-SyncerThread::SyncerThread(sessions::SyncSessionContext* context,
-    AllStatus* all_status)
+SyncerThread::SyncerThread(sessions::SyncSessionContext* context)
     : thread_main_started_(false, false),
       thread_("SyncEngine_SyncerThread"),
       vault_field_changed_(&lock_),
       p2p_authenticated_(false),
       p2p_subscribed_(false),
       conn_mgr_hookup_(NULL),
-      allstatus_(all_status),
       syncer_short_poll_interval_seconds_(kDefaultShortPollIntervalSeconds),
       syncer_long_poll_interval_seconds_(kDefaultLongPollIntervalSeconds),
       syncer_polling_interval_(kDefaultShortPollIntervalSeconds),
       syncer_max_interval_(kDefaultMaxPollIntervalMs),
       directory_manager_hookup_(NULL),
       syncer_events_(NULL),
       session_context_(context),
       disable_idle_detection_(false) {
   DCHECK(context);
   syncer_event_relay_channel_.reset(new SyncerEventChannel());
@@ skipping 251 matching lines @@
     // event.  This will also update the source of the following SyncMain call.
     bool nudged = UpdateNudgeSource(throttled, 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";
     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
 }
 
 void SyncerThread::WaitUntilConnectedOrQuit() {
   LOG(INFO) << "Syncer thread waiting for connection.";
@@ skipping 58 matching lines @@
 void SyncerThread::ExitPausedState() {
   lock_.AssertAcquired();
   vault_.paused_ = false;
   vault_field_changed_.Broadcast();
   SyncerEvent event(SyncerEvent::RESUMED);
   relay_channel()->Notify(event);
 }
 
 // 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,
     bool was_nudged) {
   lock_.AssertAcquired();  // We access 'vault' in here, so we need the lock.
   WaitInterval return_interval;
 
   // Server initiated throttling trumps everything.
   if (!silenced_until_.is_null()) {
     // We don't need to reset other state, it can continue where it left off.
     return_interval.mode = WaitInterval::THROTTLED;
     return_interval.poll_delta = silenced_until_ - TimeTicks::Now();
     return 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;
+  // Determine if the syncer has unfinished work to do.
+  SyncSessionSnapshot* snapshot = session_context_->previous_session_snapshot();
+  const bool syncer_has_work_to_do = snapshot &&
+      (snapshot->num_server_changes_remaining > snapshot->max_local_timestamp
+          || snapshot->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_polling_interval_ = (!session_context_->notifications_enabled()) ?
       syncer_short_poll_interval_seconds_ :
       syncer_long_poll_interval_seconds_;
   int default_next_wait = syncer_polling_interval_;
   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) {
       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));
+            GetRecommendedDelaySeconds(last_poll_wait));
       }
     } else {
       // No consecutive error.
       return_interval.poll_delta = TimeDelta::FromSeconds(
-           AllStatus::GetRecommendedDelaySeconds(0));
+           GetRecommendedDelaySeconds(0));
     }
     *continue_sync_cycle = true;
-  } else if (!status.notifications_enabled) {
+  } else if (!session_context_->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;
     }
@@ skipping 157 matching lines @@
     AutoLock lock(lock_);
     CheckConnected(&vault_.connected_, event.connection_code,
                    &vault_field_changed_);
   }
 }
 
 SyncerEventChannel* SyncerThread::relay_channel() {
   return syncer_event_relay_channel_.get();
 }
 
+int SyncerThread::GetRecommendedDelaySeconds(int base_delay_seconds) {
+  if (base_delay_seconds >= kMaxBackoffSeconds)
+    return kMaxBackoffSeconds;
+
+  // This calculates approx. base_delay_seconds * 2 +/- base_delay_seconds / 2
+  int backoff_s =
+      std::max(1, base_delay_seconds * kBackoffRandomizationFactor);
+
+  // Flip a coin to randomize backoff interval by +/- 50%.
+  int rand_sign = base::RandInt(0, 1) * 2 - 1;
+
+  // Truncation is adequate for rounding here.
+  backoff_s = backoff_s +
+      (rand_sign * (base_delay_seconds / kBackoffRandomizationFactor));
+
+  // Cap the backoff interval.
+  backoff_s = std::max(1, std::min(backoff_s, kMaxBackoffSeconds));
+
+  return backoff_s;
+}
+
 // Inputs and return value in milliseconds.
 int SyncerThread::CalculateSyncWaitTime(int last_interval, int user_idle_ms) {
   // syncer_polling_interval_ is in seconds
   int syncer_polling_interval_ms = syncer_polling_interval_ * 1000;
 
   // This is our default and lower bound.
   int next_wait = syncer_polling_interval_ms;
 
   // Get idle time, bounded by max wait.
   int idle = min(user_idle_ms, syncer_max_interval_);
 
   // If the user has been idle for a while, we'll start decreasing the poll
   // rate.
   if (idle >= kPollBackoffThresholdMultiplier * syncer_polling_interval_ms) {
-    next_wait = std::min(AllStatus::GetRecommendedDelaySeconds(
+    next_wait = std::min(GetRecommendedDelaySeconds(
         last_interval / 1000), syncer_max_interval_ / 1000) * 1000;
   }
 
   return next_wait;
 }
 
 // Called with mutex_ already locked.
 void SyncerThread::NudgeSyncImpl(int milliseconds_from_now,
                                  NudgeSource source) {
   // TODO(sync): Add the option to reset the backoff state machine.
@@ skipping 89 matching lines @@
     was_logged = true;
     LOG(INFO) << "UserIdleTime unimplemented on this platform, "
         "synchronization will not throttle when user idle";
   }
 #endif
 
   return 0;
 }
 
 }  // namespace browser_sync