sync: Introduce control data types

sync/engine/syncer_util.h

 // 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.
 //
 // Utility functions manipulating syncable::Entries, intended for use by the
 // syncer.
 
 #ifndef SYNC_ENGINE_SYNCER_UTIL_H_
 #define SYNC_ENGINE_SYNCER_UTIL_H_
 
@@ skipping 45 matching lines @@
 
 void SplitServerInformationIntoNewEntry(
     syncable::WriteTransaction* trans,
     syncable::MutableEntry* entry);
 
 // This function is called on an entry when we can update the user-facing data
 // from the server data.
 void UpdateLocalDataFromServerData(syncable::WriteTransaction* trans,
                                    syncable::MutableEntry* entry);
 
+// Marks the item as no longer requiring sync, allowing the server's version
+// to 'win' during the next update application step.
+void IgnoreLocalChanges(syncable::MutableEntry* entry);

[tim (not reviewing), 2012/08/22 22:42:28]

Is this actually needed outside of ConflictResolver?  It's unfortunate to add
more to this disorganized util dumping ground.  The concepts of ignoring /
overwriting changes from one side or another seem very tied to conflict
resolution. If they're needed externally to that file now, static class methods
would be slightly better from an organizational point of view, as would a
separate conflict_resolver_util file / namespace.

[rlarocque, 2012/08/23 20:11:23]

Moved to conflict_util.cc/h.

+
+// Marks the item as no longer requiring update from server data.  This will
+// cause the item to be committed to the server, overwriting the server's
+// version.
+void OverwriteServerChanges(syncable::MutableEntry* entry);
+
+// The local and server versions are identical, so unset the bits that put them
+// into a conflicting state.
+void IgnoreConflict(syncable::MutableEntry *trans);
+
 VerifyCommitResult ValidateCommitEntry(syncable::Entry* entry);
 
 VerifyResult VerifyNewEntry(const sync_pb::SyncEntity& update,
                             syncable::Entry* target,
                             const bool deleted);
 
 // Assumes we have an existing entry; check here for updates that break
 // consistency rules.
 VerifyResult VerifyUpdateConsistency(syncable::WriteTransaction* trans,
                                      const sync_pb::SyncEntity& update,
@@ skipping 34 matching lines @@
     syncable::MetahandleSet* inserted_items,
     std::vector<syncable::Id>* commit_ids);
 
 void MarkDeletedChildrenSynced(
     syncable::Directory* dir,
     std::set<syncable::Id>* deleted_folders);
 
 }  // namespace syncer
 
 #endif  // SYNC_ENGINE_SYNCER_UTIL_H_