Introduce the plumbing necessary to report Unrecoverable error from model safe workers.

chrome/browser/sync/engine/update_applicator.cc

 // Copyright (c) 2011 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/update_applicator.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
@@ skipping 61 matching lines @@
       application_results_.AddSuccess(entry.Get(syncable::ID));
       break;
     case CONFLICT:
       pointer_++;
       application_results_.AddConflict(entry.Get(syncable::ID));
       break;
     case CONFLICT_ENCRYPTION:
       pointer_++;
       application_results_.AddEncryptionConflict(entry.Get(syncable::ID));
       break;
+    case FAILED_UPDATE:
+      application_results_.set_failed_update();
+      return false;
     default:
       NOTREACHED();
       break;
   }
   VLOG(1) << "Apply Status for " << entry.Get(syncable::META_HANDLE)
           << " is " << updateResponse;
 
   return true;
 }
 
@@ skipping 27 matching lines @@
 
 void UpdateApplicator::SaveProgressIntoSessionState(
     sessions::ConflictProgress* conflict_progress,
     sessions::UpdateProgress* update_progress) {
   DCHECK(begin_ == end_ || ((pointer_ == end_) && !progress_))
       << "SaveProgress called before updates exhausted.";
 
   application_results_.SaveProgress(conflict_progress, update_progress);
 }
 
-UpdateApplicator::ResultTracker::ResultTracker(size_t num_results) {
+bool UpdateApplicator::failed_update() const {
+  return application_results_.failed_udpate();
+}
+
+UpdateApplicator::ResultTracker::ResultTracker(size_t num_results) :
+    failed_update_(false) {
   successful_ids_.reserve(num_results);
 }
 
 UpdateApplicator::ResultTracker::~ResultTracker() {
 }
 
 void UpdateApplicator::ResultTracker::AddConflict(syncable::Id id) {
   conflicting_ids_.push_back(id);
 }
 
 void UpdateApplicator::ResultTracker::AddEncryptionConflict(syncable::Id id) {
   encryption_conflict_ids_.push_back(id);
 }
 
 void UpdateApplicator::ResultTracker::AddSuccess(syncable::Id id) {
   successful_ids_.push_back(id);
 }
 
+void UpdateApplicator::ResultTracker::set_failed_update() {
+  failed_update_ = true;
+}
+
+bool UpdateApplicator::ResultTracker::failed_udpate() const {
+  return failed_update_;
+}
+
 void UpdateApplicator::ResultTracker::SaveProgress(
     sessions::ConflictProgress* conflict_progress,
     sessions::UpdateProgress* update_progress) {
   vector<syncable::Id>::const_iterator i;
   for (i = conflicting_ids_.begin(); i != conflicting_ids_.end(); ++i) {
     conflict_progress->AddConflictingItemById(*i);
     update_progress->AddAppliedUpdate(CONFLICT, *i);
   }
   for (i = encryption_conflict_ids_.begin();
        i != encryption_conflict_ids_.end(); ++i) {
@@ skipping 12 matching lines @@
 void UpdateApplicator::ResultTracker::ClearConflicts() {
   conflicting_ids_.clear();
   encryption_conflict_ids_.clear();
 }
 
 bool UpdateApplicator::ResultTracker::no_conflicts() const {
   return conflicting_ids_.empty();
 }
 
 }  // namespace browser_sync