sync: Merge GU retry logic into normal 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"
 #include "sync/protocol/sync.pb.h"
 
 namespace syncer {
 namespace sessions {
 
 size_t NudgeTracker::kDefaultMaxPayloadsPerType = 10;
 
 NudgeTracker::NudgeTracker()
-    : updates_source_(sync_pb::GetUpdatesCallerInfo::UNKNOWN),
-      invalidations_enabled_(false),
+    : invalidations_enabled_(false),
       invalidations_out_of_sync_(true) {
   ModelTypeSet protocol_types = ProtocolTypes();
   // Default initialize all the type trackers.
   for (ModelTypeSet::Iterator it = protocol_types.First(); it.Good();
        it.Inc()) {
     invalidation::ObjectId id;
     if (!RealModelTypeToObjectId(it.Get(), &id)) {
       NOTREACHED();
     } else {
       type_trackers_.insert(std::make_pair(it.Get(), DataTypeTracker(id)));
     }
   }
 }
 
 NudgeTracker::~NudgeTracker() { }
 
 bool NudgeTracker::IsSyncRequired() const {
+  if (IsRetryRequired())
+    return true;
+
   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 {
   if (invalidations_out_of_sync_)
     return true;
 
   if (IsRetryRequired())
     return true;
 
@@ skipping 10 matching lines @@
   if (sync_cycle_start_time_.is_null())
     return false;
 
   if (current_retry_time_.is_null())
     return false;
 
   return current_retry_time_ < sync_cycle_start_time_;
 }
 
 void NudgeTracker::RecordSuccessfulSyncCycle() {
-  updates_source_ = sync_pb::GetUpdatesCallerInfo::UNKNOWN;
-
   // If a retry was required, we've just serviced it.  Unset the flag.
   if (IsRetryRequired())
     current_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();
   }
 }
 
 void NudgeTracker::RecordLocalChange(ModelTypeSet types) {
-  // Don't overwrite an NOTIFICATION or DATATYPE_REFRESH source.  The server
-  // makes some assumptions about the source; overriding these sources with
-  // LOCAL could lead to incorrect behaviour.  This is part of the reason why
-  // we're deprecating 'source' in favor of 'origin'.
-  if (updates_source_ != sync_pb::GetUpdatesCallerInfo::NOTIFICATION
-      && updates_source_ != sync_pb::GetUpdatesCallerInfo::DATATYPE_REFRESH) {
-    updates_source_ = sync_pb::GetUpdatesCallerInfo::LOCAL;
-  }
-
   for (ModelTypeSet::Iterator type_it = types.First(); type_it.Good();
        type_it.Inc()) {
     TypeTrackerMap::iterator tracker_it = type_trackers_.find(type_it.Get());
     DCHECK(tracker_it != type_trackers_.end());
     tracker_it->second.RecordLocalChange();
   }
 }
 
 void NudgeTracker::RecordLocalRefreshRequest(ModelTypeSet types) {
-  // Don't overwrite an NOTIFICATION source.  The server makes some assumptions
-  // about the source.  Overriding this source with LOCAL could lead to
-  // incorrect behaviour.  This is part of the reason why we're deprecating
-  // 'source' in favor of 'origin'.
-  if (updates_source_ != sync_pb::GetUpdatesCallerInfo::NOTIFICATION) {
-    updates_source_ = sync_pb::GetUpdatesCallerInfo::DATATYPE_REFRESH;
-  }
-
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
     TypeTrackerMap::iterator tracker_it = type_trackers_.find(it.Get());
     DCHECK(tracker_it != type_trackers_.end());
     tracker_it->second.RecordLocalRefreshRequest();
   }
 }
 
 void NudgeTracker::RecordRemoteInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
-  updates_source_ = sync_pb::GetUpdatesCallerInfo::NOTIFICATION;
-
   // Be very careful here.  The invalidations acknowledgement system requires a
   // sort of manual memory management.  We'll leak a small amount of memory if
   // we fail to acknowledge or drop any of these incoming invalidations.
 
   ObjectIdSet id_set = invalidation_map.GetObjectIds();
   for (ObjectIdSet::iterator it = id_set.begin(); it != id_set.end(); ++it) {
     ModelType type;
 
     // This should never happen.  If it does, we'll start to leak memory.
     if (!ObjectIdToRealModelType(*it, &type)) {
@@ skipping 84 matching lines @@
   return result;
 }
 
 void NudgeTracker::SetLegacyNotificationHint(
     ModelType type,
     sync_pb::DataTypeProgressMarker* progress) const {
   DCHECK(type_trackers_.find(type) != type_trackers_.end());
   type_trackers_.find(type)->second.SetLegacyNotificationHint(progress);
 }
 
-sync_pb::GetUpdatesCallerInfo::GetUpdatesSource NudgeTracker::updates_source()
+sync_pb::GetUpdatesCallerInfo::GetUpdatesSource NudgeTracker::GetLegacySource()
     const {
-  return updates_source_;
+  // There's an order to these sources: NOTIFICATION, DATATYPE_REFRESH, LOCAL,
+  // RETRY.  The server makes optimization decisions based on this field, so
+  // it's important to get this right.  Setting it wrong could lead to missed
+  // updates.
+  //
+  // This complexity is part of the reason why we're deprecating 'source' in
+  // favor of 'origin'.
+  bool has_invalidation_pending = false;
+  bool has_refresh_request_pending = false;
+  bool has_commit_pending = false;
+  bool has_retry = IsRetryRequired();
+
+  for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
+       it != type_trackers_.end(); ++it) {
+    const DataTypeTracker& tracker = it->second;
+    if (!tracker.IsThrottled() && tracker.HasPendingInvalidation()) {
+      has_invalidation_pending = true;
+    }
+    if (!tracker.IsThrottled() && tracker.HasRefreshRequestPending()) {
+      has_refresh_request_pending = true;
+    }
+    if (!tracker.IsThrottled() && tracker.HasLocalChangePending()) {
+      has_commit_pending = true;
+    }
+  }
+
+  if (has_invalidation_pending) {
+    return sync_pb::GetUpdatesCallerInfo::NOTIFICATION;
+  } else if (has_refresh_request_pending) {
+    return sync_pb::GetUpdatesCallerInfo::DATATYPE_REFRESH;
+  } else if (has_commit_pending) {
+    return sync_pb::GetUpdatesCallerInfo::LOCAL;
+  } else if (has_retry) {
+    return sync_pb::GetUpdatesCallerInfo::RETRY;
+  } else {
+    return sync_pb::GetUpdatesCallerInfo::UNKNOWN;
+  }
 }
 
 void NudgeTracker::FillProtoMessage(
     ModelType type,
     sync_pb::GetUpdateTriggers* msg) const {
   DCHECK(type_trackers_.find(type) != type_trackers_.end());
 
   // Fill what we can from the global data.
   msg->set_invalidations_out_of_sync(invalidations_out_of_sync_);
 
@@ skipping 30 matching lines @@
     it->second.UpdatePayloadBufferSize(size);
   }
 }
 
 void NudgeTracker::SetNextRetryTime(base::TimeTicks retry_time) {
   next_retry_time_ = retry_time;
 }
 
 }  // namespace sessions
 }  // namespace syncer