[Sync] WorkerEntityTracker: Ensure that update and commit response have valid id.

components/sync/engine_impl/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 "components/sync/engine_impl/worker_entity_tracker.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 11 matching lines @@
 WorkerEntityTracker::~WorkerEntityTracker() {}
 
 bool WorkerEntityTracker::HasPendingCommit() const {
   return !!pending_commit_;
 }
 
 void WorkerEntityTracker::PopulateCommitProto(
     sync_pb::SyncEntity* commit_entity) const {
   DCHECK(HasPendingCommit());
 
-  if (!id_.empty()) {
-    commit_entity->set_id_string(id_);
-  }
-
   const EntityData& entity = pending_commit_->entity.value();
   DCHECK_EQ(client_tag_hash_, entity.client_tag_hash);
 
+  commit_entity->set_id_string(id_);
   commit_entity->set_client_defined_unique_tag(client_tag_hash_);
   commit_entity->set_version(base_version_);
   commit_entity->set_deleted(entity.is_deleted());
 
   // TODO(stanisc): This doesn't support bookmarks yet.
   DCHECK(entity.parent_id.empty());
   commit_entity->set_folder(false);
 
   commit_entity->set_name(entity.non_unique_name);
   if (!entity.is_deleted()) {
@@ skipping 55 matching lines @@
   // Otherwise, keep the data associated with this pending commit
   // so it can be committed at the next possible opportunity.
 }
 
 void WorkerEntityTracker::ReceiveCommitResponse(CommitResponseData* ack) {
   DCHECK_GT(ack->response_version, highest_commit_response_version_)
       << "Had expected higher response version."
       << " id: " << id_;
 
   // Commit responses, especially after the first commit, can update our ID.
+  DCHECK(!ack->id.empty());
   id_ = ack->id;
   highest_commit_response_version_ = ack->response_version;
 
   // Fill in some cached info for the response data. Since commits happen
   // synchronously on the sync thread, our item's state is guaranteed to be
   // the same at the end of the commit as it was at the start.
   ack->sequence_number = sequence_number_;
   ack->specifics_hash = pending_commit_specifics_hash_;
 
   // Because an in-progress commit blocks the sync thread, we can assume that
   // the item we just committed successfully is exactly the one we have now.
   // Nothing changed it while the commit was happening. Since we're now in
   // sync with the server, we can clear the pending commit.
   ClearPendingCommit();
 }
 
 void WorkerEntityTracker::ReceiveUpdate(const UpdateResponseData& update) {
   if (!UpdateContainsNewVersion(update))
     return;
 
   highest_gu_response_version_ = update.response_version;
+  DCHECK(!update.entity->id.empty());
   id_ = update.entity->id;
 
   // Got an applicable update newer than any pending updates. It must be safe
   // 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();
@@ skipping 54 matching lines @@
 bool WorkerEntityTracker::IsServerKnown() const {
   return base_version_ != kUncommittedVersion;
 }
 
 void WorkerEntityTracker::ClearPendingCommit() {
   pending_commit_.reset();
   pending_commit_specifics_hash_.clear();
 }
 
 }  // namespace syncer