sync: Add non-blocking type encryption support

sync/engine/entity_tracker.cc

Index: sync/engine/entity_tracker.cc
diff --git a/sync/engine/entity_tracker.cc b/sync/engine/entity_tracker.cc
index 0f10906ab15c67fc253b0e24c2115d650c0ef4b0..5340dfcf95ed113455fa83ae1c02b4bd98e25e84 100644
--- a/sync/engine/entity_tracker.cc
+++ b/sync/engine/entity_tracker.cc
@@ -193,8 +193,13 @@ void EntityTracker::ReceiveCommitResponse(const std::string& response_id,
 }
 
 void EntityTracker::ReceiveUpdate(int64 version) {
-  highest_gu_response_version_ =
-      std::max(highest_gu_response_version_, version);
+  if (version > highest_gu_response_version_) {

[Nicolas Zea, 2014/07/30 00:34:15]

It seems like it might be better to do:
if (version <= highest...)
  return

That way old versions have no effect (such as clearing pending commit)

[rlarocque, 2014/07/30 21:56:00]

Done.

+    highest_gu_response_version_ = version;
+
+    // Got an applicable update newer than any inapplicable updates.  It must
+    // be safe to discard the old inapplicable update, if there was one.
+    ClearInapplicableUpdate();
+  }
 
   if (IsInConflict()) {
     // Incoming update clobbers the pending commit on the sync thread.
@@ -203,10 +208,35 @@ void EntityTracker::ReceiveUpdate(int64 version) {
   }
 }
 
+bool EntityTracker::ReceiveInapplicableUpdate(const UpdateResponseData& data) {
+  if (data.response_version >= highest_gu_response_version_) {

[Nicolas Zea, 2014/07/30 00:34:15]

nit: I find it cleaner to just return early here too if we're not going to do
anything

Also, what is the expected behavior if the version is the same? Receive it or
ignore it? 

[rlarocque, 2014/07/30 21:56:00]

Done.
Technically it shouldn't matter, since the entities will always be identical if
they have the same ID and version.  Whether we decide to treat it as a new
update and apply it, or treat it as an old update and discard it, there should
be no practical effect in the end.

I'm using a bit of subtlety to make the code simpler, though.  In the
ModelTypeSyncWorker, I sometimes use the pattern:

EntityTracker* et = EntityTracker::InitFromUpdate(inapplicable);
et->ReceiveInapplicableUpdate(inapplicable);

That wouldn't work very well if we dropped reflections.

+    highest_gu_response_version_ = data.response_version;
+    inapplicable_update_.reset(new UpdateResponseData(data));
+    ClearPendingCommit();
+    return true;
+  }
+  return false;
+}
+
+bool EntityTracker::HasInapplicableUpdate() const {
+  return !!inapplicable_update_;
+}
+
+UpdateResponseData EntityTracker::GetInapplicableUpdate() const {
+  return *inapplicable_update_;
+}
+
+void EntityTracker::ClearInapplicableUpdate() {
+  inapplicable_update_.reset();
+}
+
 bool EntityTracker::IsInConflict() const {
   if (!is_commit_pending_)
     return false;
 
+  if (HasInapplicableUpdate())
+    return true;
+
   if (highest_gu_response_version_ <= highest_commit_response_version_) {
     // The most recent server state was created in a commit made by this
     // client.  We're fully up to date, and therefore not in conflict.