Client-side changes to support retry GU.

sync/engine/sync_scheduler_impl.cc

 // Copyright (c) 2012 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 "sync/engine/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "base/time/default_clock.h"
 #include "sync/engine/backoff_delay_provider.h"
 #include "sync/engine/syncer.h"
 #include "sync/notifier/object_id_invalidation_map.h"
 #include "sync/protocol/proto_enum_conversions.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/util/data_type_histogram.h"
 #include "sync/util/logging.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
@@ skipping 200 matching lines @@
   }
 
   DCHECK(!session_context_->account_name().empty());
   DCHECK(syncer_.get());
   Mode old_mode = mode_;
   mode_ = mode;
   AdjustPolling(UPDATE_INTERVAL);  // Will kick start poll timer if needed.
 
   if (old_mode != mode_ &&
       mode_ == NORMAL_MODE &&
-      nudge_tracker_.IsSyncRequired() &&
+      (nudge_tracker_.IsSyncRequired() ||
+          nudge_tracker_.IsRetryRequired(base::TimeTicks::Now())) &&
       CanRunNudgeJobNow(NORMAL_PRIORITY)) {
     // We just got back to normal mode.  Let's try to run the work that was
     // queued up while we were configuring.
     TrySyncSessionJob();
   }
 }
 
 ModelTypeSet SyncSchedulerImpl::GetEnabledAndUnthrottledTypes() {
   ModelTypeSet enabled_types = session_context_->enabled_types();
   ModelTypeSet throttled_types = nudge_tracker_.GetThrottledTypes();
@@ skipping 214 matching lines @@
   // Don't run poll job till the next time poll timer fires.
   do_poll_after_credentials_updated_ = false;
 
   bool success = !premature_exit
       && !sessions::HasSyncerError(
           session->status_controller().model_neutral_state());
 
   if (success) {
     // That cycle took care of any outstanding work we had.
     SDVLOG(2) << "Nudge succeeded.";
-    nudge_tracker_.RecordSuccessfulSyncCycle();
+    nudge_tracker_.RecordSuccessfulSyncCycle(base::TimeTicks::Now());
     scheduled_nudge_time_ = base::TimeTicks();
 
     // If we're here, then we successfully reached the server.  End all backoff.
     wait_interval_.reset();
     NotifyRetryTime(base::Time());
     return;
   } else {
     HandleFailure(session->status_controller().model_neutral_state());
   }
 }
@@ skipping 59 matching lines @@
         new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
         << wait_interval_->length.InMilliseconds() << "ms.";
     RestartWaiting();
   }
 }
 
 void SyncSchedulerImpl::DoPollSyncSessionJob() {
   base::AutoReset<bool> protector(&no_scheduling_allowed_, true);
 
-  if (!CanRunJobNow(NORMAL_PRIORITY)) {
-    SDVLOG(2) << "Unable to run a poll job right now.";
-    return;
-  }
-
-  if (mode_ != NORMAL_MODE) {
-    SDVLOG(2) << "Not running poll job in configure mode.";
-    return;
-  }
-
   SDVLOG(2) << "Polling with types "
-            << ModelTypeSetToString(session_context_->enabled_types());
+            << ModelTypeSetToString(GetEnabledAndUnthrottledTypes());
   scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
   syncer_->PollSyncShare(
       GetEnabledAndUnthrottledTypes(),
       session.get());
 
   AdjustPolling(FORCE_RESET);
 
   if (IsCurrentlyThrottled()) {
     SDVLOG(2) << "Poll request got us throttled.";
     // The OnSilencedUntil() call set up the WaitInterval for us.  All we need
     // to do is start the timer.
     RestartWaiting();
   }
 }
 
+void SyncSchedulerImpl::DoRetrySyncSessionJob() {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(mode_, NORMAL_MODE);
+
+  base::AutoReset<bool> protector(&no_scheduling_allowed_, true);
+
+  SDVLOG(2) << "Retrying with types "
+            << ModelTypeSetToString(GetEnabledAndUnthrottledTypes());
+  scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
+  if (syncer_->RetrySyncShare(GetEnabledAndUnthrottledTypes(),
+                              session.get()) &&
+      !sessions::HasSyncerError(
+          session->status_controller().model_neutral_state())) {
+    nudge_tracker_.RecordSuccessfulSyncCycle(base::TimeTicks::Now());
+  } else {
+    HandleFailure(session->status_controller().model_neutral_state());
+  }
+}
+
 void SyncSchedulerImpl::UpdateNudgeTimeRecords(ModelTypeSet types) {
   DCHECK(CalledOnValidThread());
   base::TimeTicks now = TimeTicks::Now();
   // Update timing information for how often datatypes are triggering nudges.
   for (ModelTypeSet::Iterator iter = types.First(); iter.Good(); iter.Inc()) {
     base::TimeTicks previous = last_local_nudges_by_model_type_[iter.Get()];
     last_local_nudges_by_model_type_[iter.Get()] = now;
     if (previous.is_null())
       continue;
 
@@ skipping 87 matching lines @@
 void SyncSchedulerImpl::TrySyncSessionJobImpl() {
   JobPriority priority = next_sync_session_job_priority_;
   next_sync_session_job_priority_ = NORMAL_PRIORITY;
 
   DCHECK(CalledOnValidThread());
   if (mode_ == CONFIGURATION_MODE) {
     if (pending_configure_params_) {
       SDVLOG(2) << "Found pending configure job";
       DoConfigurationSyncSessionJob(priority);
     }
-  } else {
-    DCHECK(mode_ == NORMAL_MODE);
-    if (nudge_tracker_.IsSyncRequired() && CanRunNudgeJobNow(priority)) {
+  } else if (CanRunNudgeJobNow(priority)) {
+    if (nudge_tracker_.IsSyncRequired()) {
       SDVLOG(2) << "Found pending nudge job";
       DoNudgeSyncSessionJob(priority);
+    } else if (nudge_tracker_.IsRetryRequired(base::TimeTicks::Now())) {
+      DoRetrySyncSessionJob();
     } else if (do_poll_after_credentials_updated_ ||
         ((base::TimeTicks::Now() - last_poll_reset_) >= GetPollInterval())) {
       DoPollSyncSessionJob();
       // Poll timer fires infrequently. Usually by this time access token is
       // already expired and poll job will fail with auth error. Set flag to
       // retry poll once ProfileSyncService gets new access token, TryCanaryJob
       // will be called after access token is retrieved.
       if (HttpResponse::SYNC_AUTH_ERROR ==
           session_context_->connection_manager()->server_status()) {
         do_poll_after_credentials_updated_ = true;
@@ skipping 29 matching lines @@
     // timer.  If we find that no_scheduling_allowed_ is set here, then
     // something is very wrong.  Maybe someone mistakenly called us directly, or
     // mishandled the book-keeping for no_scheduling_allowed_.
     NOTREACHED() << "Illegal to schedule job while session in progress.";
     return;
   }
 
   TrySyncSessionJob();
 }
 
+void SyncSchedulerImpl::RetryTimerCallback() {
+  TrySyncSessionJob();
+}
+
 void SyncSchedulerImpl::Unthrottle() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(WaitInterval::THROTTLED, wait_interval_->mode);
 
   // We're no longer throttled, so clear the wait interval.
   wait_interval_.reset();
   NotifyRetryTime(base::Time());
 
   // We treat this as a 'canary' in the sense that it was originally scheduled
   // to run some time ago, failed, and we now want to retry, versus a job that
@@ skipping 133 matching lines @@
   DCHECK(CalledOnValidThread());
   if (ShouldRequestEarlyExit(
           snapshot.model_neutral_state().sync_protocol_error)) {
     SDVLOG(2) << "Sync Scheduler requesting early exit.";
     Stop();
   }
   if (IsActionableError(snapshot.model_neutral_state().sync_protocol_error))
     OnActionableError(snapshot);
 }
 
+void SyncSchedulerImpl::OnReceivedGuRetryDelaySeconds(int delay_seconds) {
+  nudge_tracker_.set_next_retry_time(
+      base::TimeTicks::Now() + base::TimeDelta::FromSeconds(delay_seconds));
+  retry_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(delay_seconds),
+                     this, &SyncSchedulerImpl::RetryTimerCallback);
+}
+
 void SyncSchedulerImpl::SetNotificationsEnabled(bool notifications_enabled) {
   DCHECK(CalledOnValidThread());
   session_context_->set_notifications_enabled(notifications_enabled);
   if (notifications_enabled)
     nudge_tracker_.OnInvalidationsEnabled();
   else
     nudge_tracker_.OnInvalidationsDisabled();
 }
 
 base::TimeDelta SyncSchedulerImpl::GetSessionsCommitDelay() const {
   DCHECK(CalledOnValidThread());
   return sessions_commit_delay_;
 }
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer