[Sync] Rename to (Processor|Worker)EntityTracker for clarity.

The names ModelTypeEntity and EntityTracker did not express the purposes
and the similarities between the classes well. They are each essentially
internal to their respective components, and they each handle the logic
of tracking what's necessary for an entity in that component. I think
these names are much clearer.

Review URL: https://codereview.chromium.org/1739423002

Cr-Commit-Position: refs/heads/master@{#378348}

5 files changed, 78 insertions, 74 deletions

diff --git a/sync/engine/model_type_worker.cc b/sync/engine/model_type_worker.cc
index 8f58de2..1d55066 100644
--- a/sync/engine/model_type_worker.cc
+++ b/sync/engine/model_type_worker.cc
@@ -16,8 +16,8 @@
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "sync/engine/commit_contribution.h"
-#include "sync/engine/entity_tracker.h"
 #include "sync/engine/non_blocking_type_commit_contribution.h"
+#include "sync/engine/worker_entity_tracker.h"
 #include "sync/internal_api/public/model_type_processor.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/util/cryptographer.h"
@@ -134,11 +134,11 @@ SyncerError ModelTypeWorker::ProcessGetUpdatesResponse(
     UpdateResponseData response_data;
     response_data.response_version = update_entity->version();
 
-    EntityTracker* entity_tracker = nullptr;
+    WorkerEntityTracker* entity_tracker = nullptr;
     EntityMap::const_iterator map_it = entities_.find(client_tag_hash);
     if (map_it == entities_.end()) {
-      scoped_ptr<EntityTracker> scoped_entity_tracker =
-          EntityTracker::FromUpdateResponse(response_data);
+      scoped_ptr<WorkerEntityTracker> scoped_entity_tracker =
+          WorkerEntityTracker::FromUpdateResponse(response_data);
       entity_tracker = scoped_entity_tracker.get();
       entities_.insert(
           std::make_pair(client_tag_hash, std::move(scoped_entity_tracker)));
@@ -199,8 +199,8 @@ void ModelTypeWorker::ApplyUpdates(syncer::sessions::StatusController* status) {
 
     data_type_state_.set_initial_sync_done(true);
 
-    model_type_processor_->OnUpdateReceived(
-        data_type_state_, UpdateResponseDataList());
+    model_type_processor_->OnUpdateReceived(data_type_state_,
+                                            UpdateResponseDataList());
   }
 }
 
@@ -242,7 +242,7 @@ scoped_ptr<CommitContribution> ModelTypeWorker::GetContribution(
   // TODO(rlarocque): Avoid iterating here.
   for (EntityMap::const_iterator it = entities_.begin();
        it != entities_.end() && space_remaining > 0; ++it) {
-    EntityTracker* entity = it->second.get();
+    WorkerEntityTracker* entity = it->second.get();
     if (entity->HasPendingCommit()) {
       sync_pb::SyncEntity* commit_entity = commit_entities.Add();
       int64_t sequence_number = -1;
@@ -269,11 +269,11 @@ void ModelTypeWorker::StorePendingCommit(const CommitRequestData& request) {
     DCHECK_EQ(type_, syncer::GetModelTypeFromSpecifics(data.specifics));
   }
 
-  EntityTracker* entity;
+  WorkerEntityTracker* entity;
   EntityMap::const_iterator map_it = entities_.find(data.client_tag_hash);
   if (map_it == entities_.end()) {
-    scoped_ptr<EntityTracker> scoped_entity =
-        EntityTracker::FromCommitRequest(request);
+    scoped_ptr<WorkerEntityTracker> scoped_entity =
+        WorkerEntityTracker::FromCommitRequest(request);
     entity = scoped_entity.get();
     entities_.insert(
         std::make_pair(data.client_tag_hash, std::move(scoped_entity)));
@@ -299,7 +299,7 @@ void ModelTypeWorker::OnCommitResponse(
       continue;
     }
 
-    EntityTracker* entity = map_it->second.get();
+    WorkerEntityTracker* entity = map_it->second.get();
     entity->ReceiveCommitResponse(response_it->id,
                                   response_it->response_version,
                                   response_it->sequence_number);
diff --git a/sync/engine/model_type_worker.h b/sync/engine/model_type_worker.h
index 61e4b6e..34fc38f 100644
--- a/sync/engine/model_type_worker.h
+++ b/sync/engine/model_type_worker.h
@@ -32,7 +32,7 @@ class SingleThreadTaskRunner;
 namespace syncer_v2 {
 
 class ModelTypeProcessor;
-class EntityTracker;
+class WorkerEntityTracker;
 
 // A smart cache for sync types that use message passing (rather than
 // transactions and the syncable::Directory) to communicate with the sync
@@ -96,7 +96,7 @@ class SYNC_EXPORT ModelTypeWorker : public syncer::UpdateHandler,
   base::WeakPtr<ModelTypeWorker> AsWeakPtr();
 
  private:
-  using EntityMap = std::map<std::string, scoped_ptr<EntityTracker>>;
+  using EntityMap = std::map<std::string, scoped_ptr<WorkerEntityTracker>>;
 
   // Stores a single commit request in this object's internal state.
   void StorePendingCommit(const CommitRequestData& request);
@@ -112,13 +112,13 @@ class SYNC_EXPORT ModelTypeWorker : public syncer::UpdateHandler,
   bool CanCommitItems() const;
 
   // Initializes the parts of a commit entity that are the responsibility of
-  // this class, and not the EntityTracker.  Some fields, like the
+  // this class, and not the WorkerEntityTracker.  Some fields, like the
   // client-assigned ID, can only be set by an entity with knowledge of the
   // entire data type's state.
   void HelpInitializeCommitEntity(sync_pb::SyncEntity* commit_entity);
 
   // Attempts to decrypt pending updates stored in the EntityMap.  If
-  // successful, will remove the update from the its EntityTracker and forward
+  // successful, will remove the update from the its tracker and forward
   // it to the proxy thread for application.  Will forward any new encryption
   // keys to the proxy to trigger re-encryption if necessary.
   void OnCryptographerUpdated();
diff --git a/sync/engine/entity_tracker.cc b/sync/engine/worker_entity_tracker.cc
index a209c09..33ab384 100644
--- a/sync/engine/entity_tracker.cc
+++ b/sync/engine/worker_entity_tracker.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/engine/entity_tracker.h"
+#include "sync/engine/worker_entity_tracker.h"
 
 #include <stdint.h>
 
@@ -14,22 +14,23 @@
 
 namespace syncer_v2 {
 
-scoped_ptr<EntityTracker> EntityTracker::FromUpdateResponse(
+scoped_ptr<WorkerEntityTracker> WorkerEntityTracker::FromUpdateResponse(
     const UpdateResponseData& data) {
-  return make_scoped_ptr(new EntityTracker(
+  return make_scoped_ptr(new WorkerEntityTracker(
       data.entity->id, data.entity->client_tag_hash, 0, data.response_version));
 }
 
-scoped_ptr<EntityTracker> EntityTracker::FromCommitRequest(
+scoped_ptr<WorkerEntityTracker> WorkerEntityTracker::FromCommitRequest(
     const CommitRequestData& data) {
-  return make_scoped_ptr(
-      new EntityTracker(data.entity->id, data.entity->client_tag_hash, 0, 0));
+  return make_scoped_ptr(new WorkerEntityTracker(
+      data.entity->id, data.entity->client_tag_hash, 0, 0));
 }
 
-EntityTracker::EntityTracker(const std::string& id,
-                             const std::string& client_tag_hash,
-                             int64_t highest_commit_response_version,
-                             int64_t highest_gu_response_version)
+WorkerEntityTracker::WorkerEntityTracker(
+    const std::string& id,
+    const std::string& client_tag_hash,
+    int64_t highest_commit_response_version,
+    int64_t highest_gu_response_version)
     : id_(id),
       client_tag_hash_(client_tag_hash),
       highest_commit_response_version_(highest_commit_response_version),
@@ -37,14 +38,14 @@ EntityTracker::EntityTracker(const std::string& id,
       sequence_number_(0),
       base_version_(kUncommittedVersion) {}
 
-EntityTracker::~EntityTracker() {}
+WorkerEntityTracker::~WorkerEntityTracker() {}
 
-bool EntityTracker::HasPendingCommit() const {
+bool WorkerEntityTracker::HasPendingCommit() const {
   return !!pending_commit_;
 }
 
-void EntityTracker::PrepareCommitProto(sync_pb::SyncEntity* commit_entity,
-                                       int64_t* sequence_number) const {
+void WorkerEntityTracker::PrepareCommitProto(sync_pb::SyncEntity* commit_entity,
+                                             int64_t* sequence_number) const {
   DCHECK(HasPendingCommit());
   DCHECK(!client_tag_hash_.empty());
 
@@ -73,7 +74,7 @@ void EntityTracker::PrepareCommitProto(sync_pb::SyncEntity* commit_entity,
   *sequence_number = sequence_number_;
 }
 
-void EntityTracker::RequestCommit(const CommitRequestData& data) {
+void WorkerEntityTracker::RequestCommit(const CommitRequestData& data) {
   DCHECK_GE(data.base_version, base_version_)
       << "Base version should never decrease";
 
@@ -116,9 +117,9 @@ void EntityTracker::RequestCommit(const CommitRequestData& data) {
   // so it can be committed at the next possible opportunity.
 }
 
-void EntityTracker::ReceiveCommitResponse(const std::string& response_id,
-                                          int64_t response_version,
-                                          int64_t sequence_number) {
+void WorkerEntityTracker::ReceiveCommitResponse(const std::string& response_id,
+                                                int64_t response_version,
+                                                int64_t sequence_number) {
   // Commit responses, especially after the first commit, can update our ID.
   id_ = response_id;
 
@@ -141,7 +142,7 @@ void EntityTracker::ReceiveCommitResponse(const std::string& response_id,
   ClearPendingCommit();
 }
 
-void EntityTracker::ReceiveUpdate(int64_t version) {
+void WorkerEntityTracker::ReceiveUpdate(int64_t version) {
   if (version <= highest_gu_response_version_)
     return;
 
@@ -158,7 +159,7 @@ void EntityTracker::ReceiveUpdate(int64_t version) {
   }
 }
 
-bool EntityTracker::ReceivePendingUpdate(const UpdateResponseData& data) {
+bool WorkerEntityTracker::ReceivePendingUpdate(const UpdateResponseData& data) {
   if (data.response_version < highest_gu_response_version_)
     return false;
 
@@ -168,19 +169,19 @@ bool EntityTracker::ReceivePendingUpdate(const UpdateResponseData& data) {
   return true;
 }
 
-bool EntityTracker::HasPendingUpdate() const {
+bool WorkerEntityTracker::HasPendingUpdate() const {
   return !!pending_update_;
 }
 
-UpdateResponseData EntityTracker::GetPendingUpdate() const {
+UpdateResponseData WorkerEntityTracker::GetPendingUpdate() const {
   return *pending_update_;
 }
 
-void EntityTracker::ClearPendingUpdate() {
+void WorkerEntityTracker::ClearPendingUpdate() {
   pending_update_.reset();
 }
 
-bool EntityTracker::IsInConflict() const {
+bool WorkerEntityTracker::IsInConflict() const {
   if (!HasPendingCommit())
     return false;
 
@@ -203,11 +204,11 @@ bool EntityTracker::IsInConflict() const {
   }
 }
 
-bool EntityTracker::IsServerKnown() const {
+bool WorkerEntityTracker::IsServerKnown() const {
   return base_version_ != kUncommittedVersion;
 }
 
-void EntityTracker::ClearPendingCommit() {
+void WorkerEntityTracker::ClearPendingCommit() {
   pending_commit_.reset();
 }
 
diff --git a/sync/engine/entity_tracker.h b/sync/engine/worker_entity_tracker.h
index e0e66f6..5f413e0 100644
--- a/sync/engine/entity_tracker.h
+++ b/sync/engine/worker_entity_tracker.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef SYNC_ENGINE_ENTITY_TRACKER_H_
-#define SYNC_ENGINE_ENTITY_TRACKER_H_
+#ifndef SYNC_ENGINE_WORKER_ENTITY_TRACKER_H_
+#define SYNC_ENGINE_WORKER_ENTITY_TRACKER_H_
 
 #include <stdint.h>
 
@@ -31,16 +31,16 @@ struct UpdateResponseData;
 //
 // This object may contain state associated with a pending commit, pending
 // update, or both.
-class SYNC_EXPORT EntityTracker {
+class SYNC_EXPORT WorkerEntityTracker {
  public:
-  ~EntityTracker();
+  ~WorkerEntityTracker();
 
   // Initialize a new entity based on an update response.
-  static scoped_ptr<EntityTracker> FromUpdateResponse(
+  static scoped_ptr<WorkerEntityTracker> FromUpdateResponse(
       const UpdateResponseData& data);
 
   // Initialize a new entity based on a commit request.
-  static scoped_ptr<EntityTracker> FromCommitRequest(
+  static scoped_ptr<WorkerEntityTracker> FromCommitRequest(
       const CommitRequestData& data);
 
   // Returns true if this entity should be commited to the server.
@@ -85,10 +85,10 @@ class SYNC_EXPORT EntityTracker {
  private:
   // Initializes the entity tracker's main fields. Does not initialize state
   // related to a pending commit.
-  EntityTracker(const std::string& id,
-                const std::string& client_tag_hash,
-                int64_t highest_commit_response_version,
-                int64_t highest_gu_response_version);
+  WorkerEntityTracker(const std::string& id,
+                      const std::string& client_tag_hash,
+                      int64_t highest_commit_response_version,
+                      int64_t highest_gu_response_version);
 
   // Checks if the current state indicates a conflict.
   //
@@ -130,9 +130,9 @@ class SYNC_EXPORT EntityTracker {
   // source of pending updates is updates that can't currently be decrypted.
   scoped_ptr<UpdateResponseData> pending_update_;
 
-  DISALLOW_COPY_AND_ASSIGN(EntityTracker);
+  DISALLOW_COPY_AND_ASSIGN(WorkerEntityTracker);
 };
 
 }  // namespace syncer_v2
 
-#endif  // SYNC_ENGINE_ENTITY_TRACKER_H_
+#endif  // SYNC_ENGINE_WORKER_ENTITY_TRACKER_H_
diff --git a/sync/engine/entity_tracker_unittest.cc b/sync/engine/worker_entity_tracker_unittest.cc
index 6ba3222..8a30b6a 100644
--- a/sync/engine/entity_tracker_unittest.cc
+++ b/sync/engine/worker_entity_tracker_unittest.cc
@@ -3,7 +3,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/engine/entity_tracker.h"
+#include "sync/engine/worker_entity_tracker.h"
 
 #include <stdint.h>
 
@@ -17,17 +17,17 @@
 
 namespace syncer_v2 {
 
-// Some simple tests for the EntityTracker.
+// Some simple tests for the WorkerEntityTracker.
 //
-// The EntityTracker is an implementation detail of the ModelTypeWorker.
+// The WorkerEntityTracker is an implementation detail of the ModelTypeWorker.
 // As such, it doesn't make much sense to test it exhaustively, since it
 // already gets a lot of test coverage from the ModelTypeWorker unit tests.
 //
 // These tests are intended as a basic sanity check.  Anything more complicated
 // would be redundant.
-class EntityTrackerTest : public ::testing::Test {
+class WorkerEntityTrackerTest : public ::testing::Test {
  public:
-  EntityTrackerTest()
+  WorkerEntityTrackerTest()
       : kServerId("ServerID"),
         kClientTag("some.sample.tag"),
         kClientTagHash(
@@ -39,7 +39,7 @@ class EntityTrackerTest : public ::testing::Test {
     specifics.mutable_preference()->set_value("pref.value");
   }
 
-  ~EntityTrackerTest() override {}
+  ~WorkerEntityTrackerTest() override {}
 
   CommitRequestData MakeCommitRequestData(int64_t sequence_number,
                                           int64_t base_version) {
@@ -78,9 +78,9 @@ class EntityTrackerTest : public ::testing::Test {
 };
 
 // Construct a new entity from a server update.  Then receive another update.
-TEST_F(EntityTrackerTest, FromUpdateResponse) {
-  scoped_ptr<EntityTracker> entity(
-      EntityTracker::FromUpdateResponse(MakeUpdateResponseData(10)));
+TEST_F(WorkerEntityTrackerTest, FromUpdateResponse) {
+  scoped_ptr<WorkerEntityTracker> entity(
+      WorkerEntityTracker::FromUpdateResponse(MakeUpdateResponseData(10)));
   EXPECT_FALSE(entity->HasPendingCommit());
 
   entity->ReceiveUpdate(20);
@@ -88,11 +88,12 @@ TEST_F(EntityTrackerTest, FromUpdateResponse) {
 }
 
 // Construct a new entity from a commit request.  Then serialize it.
-TEST_F(EntityTrackerTest, FromCommitRequest) {
+TEST_F(WorkerEntityTrackerTest, FromCommitRequest) {
   const int64_t kSequenceNumber = 22;
   const int64_t kBaseVersion = 33;
   CommitRequestData data = MakeCommitRequestData(kSequenceNumber, kBaseVersion);
-  scoped_ptr<EntityTracker> entity(EntityTracker::FromCommitRequest(data));
+  scoped_ptr<WorkerEntityTracker> entity(
+      WorkerEntityTracker::FromCommitRequest(data));
   entity->RequestCommit(data);
 
   ASSERT_TRUE(entity->HasPendingCommit());
@@ -113,9 +114,9 @@ TEST_F(EntityTrackerTest, FromCommitRequest) {
 }
 
 // Start with a server initiated entity.  Commit over top of it.
-TEST_F(EntityTrackerTest, RequestCommit) {
-  scoped_ptr<EntityTracker> entity(
-      EntityTracker::FromUpdateResponse(MakeUpdateResponseData(10)));
+TEST_F(WorkerEntityTrackerTest, RequestCommit) {
+  scoped_ptr<WorkerEntityTracker> entity(
+      WorkerEntityTracker::FromUpdateResponse(MakeUpdateResponseData(10)));
 
   entity->RequestCommit(MakeCommitRequestData(1, 10));
 
@@ -124,9 +125,9 @@ TEST_F(EntityTrackerTest, RequestCommit) {
 
 // Start with a server initiated entity.  Fail to request a commit because of
 // an out of date base version.
-TEST_F(EntityTrackerTest, RequestCommitFailure) {
-  scoped_ptr<EntityTracker> entity(
-      EntityTracker::FromUpdateResponse(MakeUpdateResponseData(10)));
+TEST_F(WorkerEntityTrackerTest, RequestCommitFailure) {
+  scoped_ptr<WorkerEntityTracker> entity(
+      WorkerEntityTracker::FromUpdateResponse(MakeUpdateResponseData(10)));
   EXPECT_FALSE(entity->HasPendingCommit());
 
   entity->RequestCommit(MakeCommitRequestData(23, 5 /* base_version 5 < 10 */));
@@ -134,9 +135,10 @@ TEST_F(EntityTrackerTest, RequestCommitFailure) {
 }
 
 // Start with a pending commit.  Clobber it with an incoming update.
-TEST_F(EntityTrackerTest, UpdateClobbersCommit) {
+TEST_F(WorkerEntityTrackerTest, UpdateClobbersCommit) {
   CommitRequestData data = MakeCommitRequestData(22, 33);
-  scoped_ptr<EntityTracker> entity(EntityTracker::FromCommitRequest(data));
+  scoped_ptr<WorkerEntityTracker> entity(
+      WorkerEntityTracker::FromCommitRequest(data));
   entity->RequestCommit(data);
 
   EXPECT_TRUE(entity->HasPendingCommit());
@@ -147,9 +149,10 @@ TEST_F(EntityTrackerTest, UpdateClobbersCommit) {
 
 // Start with a pending commit.  Send it a reflected update that
 // will not override the in-progress commit.
-TEST_F(EntityTrackerTest, ReflectedUpdateDoesntClobberCommit) {
+TEST_F(WorkerEntityTrackerTest, ReflectedUpdateDoesntClobberCommit) {
   CommitRequestData data = MakeCommitRequestData(22, 33);
-  scoped_ptr<EntityTracker> entity(EntityTracker::FromCommitRequest(data));
+  scoped_ptr<WorkerEntityTracker> entity(
+      WorkerEntityTracker::FromCommitRequest(data));
   entity->RequestCommit(data);
 
   EXPECT_TRUE(entity->HasPendingCommit());