Client-side changes to support retry GU.

sync/sessions/nudge_tracker.cc

 // Copyright (c) 2013 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/sessions/nudge_tracker.h"
 
 #include "base/basictypes.h"
 #include "sync/internal_api/public/base/invalidation.h"
 #include "sync/notifier/invalidation_util.h"
 #include "sync/notifier/object_id_invalidation_map.h"
@@ skipping 16 matching lines @@
     if (!RealModelTypeToObjectId(it.Get(), &id)) {
       NOTREACHED();
     } else {
       type_trackers_.insert(std::make_pair(it.Get(), DataTypeTracker(id)));
     }
   }
 }
 
 NudgeTracker::~NudgeTracker() { }
 
 bool NudgeTracker::IsSyncRequired() const {

[rlarocque, 2014/01/08 20:30:08]

I'm pretty sure this should return true if IsRetryRequired() is true.  I think
it's currently assumed that IsGetUpdatesRequired() necessarily implies
IsSyncRequired().  

This may change when we split we eventually define a separate
IsCommitRequired(), but we should probably keep the assumption for now.

[haitaol1, 2014/01/09 00:30:44]

I didn't call IsRetryRequired() here because that will execute the normal sync
path. But I'd like to avoid mixing for now to keep it simple given that retry
and pre-commit GU will co-exist for a while. Also IsGetUpdatesRequired() checks
invalidation but IsSyncRequired() 
doesn't. Not sure if that's intentional.

On 2014/01/08 20:30:08, rlarocque wrote:

[rlarocque, 2014/01/09 00:37:21]

At the moment, I'm not sure either.  :)

It's been a while.  Maybe there was some intent to start making the two diverge.

Anyway, if we're already at the point where IsGetUpdatesRequired() does not
necessarily imply that IsSyncRequired(), then I see no problem in taking another
step in that direction.  You can keep the code as is.

   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     if (it->second.IsSyncRequired()) {
       return true;
     }
   }
   return false;
 }
 
-bool NudgeTracker::IsGetUpdatesRequired() const {
+bool NudgeTracker::IsGetUpdatesRequired(base::TimeTicks now) const {
   if (invalidations_out_of_sync_)
     return true;
+
+  if (IsRetryRequired(now))
+    return true;
+
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     if (it->second.IsGetUpdatesRequired()) {
       return true;
     }
   }
   return false;
 }
 
-void NudgeTracker::RecordSuccessfulSyncCycle() {
+bool NudgeTracker::IsRetryRequired(base::TimeTicks now) const {
+  return !next_retry_time_.is_null() && next_retry_time_ < now;
+}
+
+void NudgeTracker::RecordSuccessfulSyncCycle(base::TimeTicks now) {
   updates_source_ = sync_pb::GetUpdatesCallerInfo::UNKNOWN;
+  last_successful_sync_time_ = now;
+
+  if (next_retry_time_ < now)
+    next_retry_time_ = base::TimeTicks();
 
   // A successful cycle while invalidations are enabled puts us back into sync.
   invalidations_out_of_sync_ = !invalidations_enabled_;
 
   for (TypeTrackerMap::iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     it->second.RecordSuccessfulSyncCycle();
   }
 }
 
@@ skipping 158 matching lines @@
 
 void NudgeTracker::SetHintBufferSize(size_t size) {
   for (TypeTrackerMap::iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     it->second.UpdatePayloadBufferSize(size);
   }
 }
 
 }  // namespace sessions
 }  // namespace syncer