Sync commit errors should temporarily re-enable trigger pre-commit getupdates

sync/sessions/data_type_tracker.cc

 // Copyright 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/data_type_tracker.h"
 
 #include "base/logging.h"
 #include "sync/internal_api/public/base/invalidation_interface.h"
 #include "sync/sessions/nudge_tracker.h"
 
 namespace syncer {
 namespace sessions {
 
 DataTypeTracker::DataTypeTracker()
     : local_nudge_count_(0),
       local_refresh_request_count_(0),
       payload_buffer_size_(NudgeTracker::kDefaultMaxPayloadsPerType),
-      initial_sync_required_(false) {
+      initial_sync_required_(false),
+      sync_required_to_resolve_conflict_(false) {
 }
 
 DataTypeTracker::~DataTypeTracker() { }
 
 base::TimeDelta DataTypeTracker::RecordLocalChange() {
   local_nudge_count_++;
   return nudge_delay_;
 }
 
 void DataTypeTracker::RecordLocalRefreshRequest() {
@@ skipping 56 matching lines @@
     last_dropped_invalidation_.reset(pending_invalidations_.front());
     last_dropped_invalidation_->Drop();
     pending_invalidations_.weak_erase(pending_invalidations_.begin());
   }
 }
 
 void DataTypeTracker::RecordInitialSyncRequired() {
   initial_sync_required_ = true;
 }
 
+void DataTypeTracker::RecordCommitConflict() {
+  sync_required_to_resolve_conflict_ = true;
+}
+
 void DataTypeTracker::RecordSuccessfulSyncCycle() {
   // If we were throttled, then we would have been excluded from this cycle's
   // GetUpdates and Commit actions.  Our state remains unchanged.
   if (IsThrottled())
     return;
 
   local_nudge_count_ = 0;
   local_refresh_request_count_ = 0;
 
   // TODO(rlarocque): If we want this to be correct even if we should happen to
   // crash before writing all our state, we should wait until the results of
   // this sync cycle have been written to disk before updating the invalidations
   // state.  See crbug.com/324996.
   for (ScopedVector<InvalidationInterface>::const_iterator it =
            pending_invalidations_.begin();
        it != pending_invalidations_.end();
        ++it) {
     (*it)->Acknowledge();
   }
   pending_invalidations_.clear();
 
   if (last_dropped_invalidation_) {
     last_dropped_invalidation_->Acknowledge();
     last_dropped_invalidation_.reset();
   }
 
   initial_sync_required_ = false;
+  sync_required_to_resolve_conflict_ = false;
 }
 
 // This limit will take effect on all future invalidations received.
 void DataTypeTracker::UpdatePayloadBufferSize(size_t new_size) {
   payload_buffer_size_ = new_size;
 }
 
 bool DataTypeTracker::IsSyncRequired() const {
   return !IsThrottled() && (HasLocalChangePending() || IsGetUpdatesRequired());
 }
 
 bool DataTypeTracker::IsGetUpdatesRequired() const {
   return !IsThrottled() &&
          (HasRefreshRequestPending() || HasPendingInvalidation() ||
-          IsInitialSyncRequired());
+          IsInitialSyncRequired() || IsSyncRequiredToResolveConflict());
 }
 
 bool DataTypeTracker::HasLocalChangePending() const {
   return local_nudge_count_ > 0;
 }
 
 bool DataTypeTracker::HasRefreshRequestPending() const {
   return local_refresh_request_count_ > 0;
 }
 
 bool DataTypeTracker::HasPendingInvalidation() const {
   return !pending_invalidations_.empty() || last_dropped_invalidation_;
 }
 
 bool DataTypeTracker::IsInitialSyncRequired() const {
   return initial_sync_required_;
 }
 
+bool DataTypeTracker::IsSyncRequiredToResolveConflict() const {
+  return sync_required_to_resolve_conflict_;
+}
+
 void DataTypeTracker::SetLegacyNotificationHint(
     sync_pb::DataTypeProgressMarker* progress) const {
   DCHECK(!IsThrottled())
       << "We should not make requests if the type is throttled.";
 
   if (!pending_invalidations_.empty() &&
       !pending_invalidations_.back()->IsUnknownVersion()) {
     // The old-style source info can contain only one hint per type.  We grab
     // the most recent, to mimic the old coalescing behaviour.
     progress->set_notification_hint(
@@ skipping 20 matching lines @@
     }
   }
 
   msg->set_server_dropped_hints(
       !pending_invalidations_.empty() &&
       (*pending_invalidations_.begin())->IsUnknownVersion());
   msg->set_client_dropped_hints(last_dropped_invalidation_);
   msg->set_local_modification_nudges(local_nudge_count_);
   msg->set_datatype_refresh_nudges(local_refresh_request_count_);
   msg->set_initial_sync_in_progress(initial_sync_required_);
+  msg->set_sync_for_resolve_conflict_in_progress(
+      sync_required_to_resolve_conflict_);
 }
 
 bool DataTypeTracker::IsThrottled() const {
   return !unthrottle_time_.is_null();
 }
 
 base::TimeDelta DataTypeTracker::GetTimeUntilUnthrottle(
     base::TimeTicks now) const {
   if (!IsThrottled()) {
     NOTREACHED();
@@ skipping 13 matching lines @@
     unthrottle_time_ = base::TimeTicks();
   }
 }
 
 void DataTypeTracker::UpdateLocalNudgeDelay(base::TimeDelta delay) {
   nudge_delay_ = delay;
 }
 
 }  // namespace sessions
 }  // namespace syncer