[Sync] Accumulate GU response chunks in the Worker.

sync/engine/worker_entity_tracker.cc

 // Copyright 2014 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/engine/worker_entity_tracker.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "sync/internal_api/public/base/model_type.h"
@@ skipping 118 matching lines @@
   ClearPendingCommit();
 }
 
 void WorkerEntityTracker::ReceiveUpdate(int64_t version) {
   if (version <= highest_gu_response_version_)
     return;
 
   highest_gu_response_version_ = version;
 
   // Got an applicable update newer than any pending updates.  It must be safe
-  // to discard the old pending update, if there was one.
-  ClearPendingUpdate();
+  // to discard the old encrypted update, if there was one.
+  ClearEncryptedUpdate();
 
   if (IsInConflict()) {
     // Incoming update clobbers the pending commit on the sync thread.
     // The model thread can re-request this commit later if it wants to.
     ClearPendingCommit();
   }
 }
 
-bool WorkerEntityTracker::ReceivePendingUpdate(const UpdateResponseData& data) {
+bool WorkerEntityTracker::ReceiveEncryptedUpdate(
+    const UpdateResponseData& data) {
   if (data.response_version < highest_gu_response_version_)
     return false;
 
   highest_gu_response_version_ = data.response_version;
-  pending_update_.reset(new UpdateResponseData(data));
+  encrypted_update_.reset(new UpdateResponseData(data));
   ClearPendingCommit();
   return true;
 }
 
-bool WorkerEntityTracker::HasPendingUpdate() const {
-  return !!pending_update_;
+bool WorkerEntityTracker::HasEncryptedUpdate() const {
+  return !!encrypted_update_;
 }
 
-UpdateResponseData WorkerEntityTracker::GetPendingUpdate() const {
-  return *pending_update_;
+UpdateResponseData WorkerEntityTracker::GetEncryptedUpdate() const {
+  return *encrypted_update_;
 }
 
-void WorkerEntityTracker::ClearPendingUpdate() {
-  pending_update_.reset();
+void WorkerEntityTracker::ClearEncryptedUpdate() {
+  encrypted_update_.reset();
 }
 
 bool WorkerEntityTracker::IsInConflict() const {
   if (!HasPendingCommit())
     return false;
 
-  if (HasPendingUpdate())
+  if (HasEncryptedUpdate())
     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.
     return false;
   } else {
     // The most recent server state was written by someone else.
     // Did the model thread have the most up to date version when it issued the
     // commit request?
     if (base_version_ >= highest_gu_response_version_) {
       return false;  // Yes.
     } else {
       return true;  // No.
     }
   }
 }
 
 bool WorkerEntityTracker::IsServerKnown() const {
   return base_version_ != kUncommittedVersion;
 }
 
 void WorkerEntityTracker::ClearPendingCommit() {
   pending_commit_.reset();
 }
 
 }  // namespace syncer_v2