[Sync] Add a sanity integration test for USS.

components/sync/test/fake_server/fake_server.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/test/fake_server/fake_server.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 82 matching lines @@
   // part of a GetUpdatesResponse.
   bool ClientWantsItem(const FakeServerEntity& entity) const {
     int64_t version = entity.GetVersion();
     if (version <= min_version_) {
       return false;
     } else if (entity.IsDeleted()) {
       return true;
     }
 
     ModelTypeToVersionMap::const_iterator it =
-        request_from_version_.find(entity.GetModelType());
+        request_from_version_.find(entity.model_type());
 
     return it == request_from_version_.end() ? false : it->second < version;
   }
 
   // Returns the minimum version seen across all types.
   int64_t GetMinVersion() const { return min_version_; }
 
  private:
   typedef std::map<ModelType, int64_t> ModelTypeToVersionMap;
 
@@ skipping 111 matching lines @@
 
   return true;
 }
 
 void FakeServer::UpdateEntityVersion(FakeServerEntity* entity) {
   entity->SetVersion(++version_);
 }
 
 void FakeServer::SaveEntity(std::unique_ptr<FakeServerEntity> entity) {
   UpdateEntityVersion(entity.get());
-  entities_[entity->GetId()] = std::move(entity);
+  entities_[entity->id()] = std::move(entity);
 }
 
 void FakeServer::HandleCommand(const string& request,
                                const base::Closure& completion_closure,
                                int* error_code,
                                int* response_code,
                                std::string* response) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!network_enabled_) {
     *error_code = net::ERR_FAILED;
@@ skipping 115 matching lines @@
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     const FakeServerEntity& entity = *it->second;
     if (sieve->ClientWantsItem(entity)) {
       sync_pb::SyncEntity* response_entity = response->add_entries();
       entity.SerializeAsProto(response_entity);
 
       max_response_version =
           std::max(max_response_version, response_entity->version());
 
-      if (entity.GetModelType() == syncer::NIGORI) {
+      if (entity.model_type() == syncer::NIGORI) {
         send_encryption_keys_based_on_nigori =
             response_entity->specifics().nigori().passphrase_type() ==
             sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE;
       }
     }
   }
 
   if (send_encryption_keys_based_on_nigori ||
       get_updates.need_encryption_key()) {
     for (vector<string>::iterator it = keystore_keys_.begin();
@@ skipping 10 matching lines @@
     const sync_pb::SyncEntity& client_entity,
     sync_pb::CommitResponse_EntryResponse* entry_response,
     const string& client_guid,
     const string& parent_id) {
   if (client_entity.version() == 0 && client_entity.deleted()) {
     return string();
   }
 
   std::unique_ptr<FakeServerEntity> entity;
   if (client_entity.deleted()) {
-    entity = TombstoneEntity::Create(client_entity.id_string());
+    entity = TombstoneEntity::Create(client_entity.id_string(),
+                                     client_entity.client_defined_unique_tag());
     DeleteChildren(client_entity.id_string());
   } else if (GetModelType(client_entity) == syncer::NIGORI) {
     // NIGORI is the only permanent item type that should be updated by the
     // client.
     EntityMap::const_iterator iter = entities_.find(client_entity.id_string());
     CHECK(iter != entities_.end());
     entity = PermanentEntity::CreateUpdatedNigoriEntity(client_entity,
                                                         *iter->second);
   } else if (client_entity.has_client_defined_unique_tag()) {
     entity = UniqueClientEntity::Create(client_entity);
   } else {
     // TODO(pvalenzuela): Validate entity's parent ID.
     EntityMap::const_iterator iter = entities_.find(client_entity.id_string());
     if (iter != entities_.end()) {
       entity = BookmarkEntity::CreateUpdatedVersion(client_entity,
                                                     *iter->second, parent_id);
     } else {
       entity = BookmarkEntity::CreateNew(client_entity, parent_id, client_guid);
     }
   }
 
   if (!entity) {
     // TODO(pvalenzuela): Add logging so that it is easier to determine why
     // creation failed.
     return string();
   }
 
-  const std::string id = entity->GetId();
+  const std::string id = entity->id();
   SaveEntity(std::move(entity));
   BuildEntryResponseForSuccessfulCommit(id, entry_response);
   return id;
 }
 
 void FakeServer::BuildEntryResponseForSuccessfulCommit(
     const std::string& entity_id,
     sync_pb::CommitResponse_EntryResponse* entry_response) {
   EntityMap::const_iterator iter = entities_.find(entity_id);
   CHECK(iter != entities_.end());
   const FakeServerEntity& entity = *iter->second;
   entry_response->set_response_type(sync_pb::CommitResponse::SUCCESS);
-  entry_response->set_id_string(entity.GetId());
+  entry_response->set_id_string(entity.id());
 
   if (entity.IsDeleted()) {
     entry_response->set_version(entity.GetVersion() + 1);
   } else {
     entry_response->set_version(entity.GetVersion());
     entry_response->set_name(entity.GetName());
   }
 }
 
 bool FakeServer::IsChild(const string& id, const string& potential_parent_id) {
   EntityMap::const_iterator iter = entities_.find(id);
   if (iter == entities_.end()) {
     // We've hit an ID (probably the imaginary root entity) that isn't stored
     // by the server, so it can't be a child.
     return false;
   }
 
   const FakeServerEntity& entity = *iter->second;
   if (entity.GetParentId() == potential_parent_id)
     return true;
 
   // Recursively look up the tree.
   return IsChild(entity.GetParentId(), potential_parent_id);
 }
 
 void FakeServer::DeleteChildren(const string& id) {
-  std::set<string> tombstones_ids;
+  std::vector<std::unique_ptr<FakeServerEntity>> tombstones;
   // Find all the children of id.
-  for (auto& entity : entities_) {
+  for (const auto& entity : entities_) {
     if (IsChild(entity.first, id)) {
-      tombstones_ids.insert(entity.first);
+      tombstones.push_back(TombstoneEntity::Create(
+          entity.first, entity.second->client_defined_unique_tag()));
     }
   }
 
-  for (auto& tombstone_id : tombstones_ids) {
-    SaveEntity(TombstoneEntity::Create(tombstone_id));
+  for (auto& tombstone : tombstones) {
+    SaveEntity(std::move(tombstone));
   }
 }
 
 bool FakeServer::HandleCommitRequest(const sync_pb::CommitMessage& commit,
                                      const std::string& invalidator_client_id,
                                      sync_pb::CommitResponse* response) {
   std::map<string, string> client_to_server_ids;
   string guid = commit.cache_guid();
   ModelTypeSet committed_model_types;
 
@@ skipping 15 matching lines @@
       return false;
     }
 
     // Record the ID if it was renamed.
     if (entity_id != client_entity.id_string()) {
       client_to_server_ids[client_entity.id_string()] = entity_id;
     }
 
     EntityMap::const_iterator iter = entities_.find(entity_id);
     CHECK(iter != entities_.end());
-    committed_model_types.Put(iter->second->GetModelType());
+    committed_model_types.Put(iter->second->model_type());
   }
 
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCommit(invalidator_client_id, committed_model_types));
   return true;
 }
 
 std::unique_ptr<base::DictionaryValue>
 FakeServer::GetEntitiesAsDictionaryValue() {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::unique_ptr<base::DictionaryValue> dictionary(
       new base::DictionaryValue());
 
   // Initialize an empty ListValue for all ModelTypes.
   ModelTypeSet all_types = ModelTypeSet::All();
   for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
     dictionary->Set(ModelTypeToString(it.Get()), new base::ListValue());
   }
 
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     const FakeServerEntity& entity = *it->second;
     if (IsDeletedOrPermanent(entity)) {
       // Tombstones are ignored as they don't represent current data. Folders
       // are also ignored as current verification infrastructure does not
       // consider them.
       continue;
     }
     base::ListValue* list_value;
-    if (!dictionary->GetList(ModelTypeToString(entity.GetModelType()),
+    if (!dictionary->GetList(ModelTypeToString(entity.model_type()),
                              &list_value)) {
       return std::unique_ptr<base::DictionaryValue>();
     }
     // TODO(pvalenzuela): Store more data for each entity so additional
     // verification can be performed. One example of additional verification
     // is checking the correctness of the bookmark hierarchy.
     list_value->AppendString(entity.GetName());
   }
 
   return dictionary;
 }
 
 std::vector<sync_pb::SyncEntity> FakeServer::GetSyncEntitiesByModelType(
     ModelType model_type) {
   std::vector<sync_pb::SyncEntity> sync_entities;
   DCHECK(thread_checker_.CalledOnValidThread());
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     const FakeServerEntity& entity = *it->second;
-    if (!IsDeletedOrPermanent(entity) && entity.GetModelType() == model_type) {
+    if (!IsDeletedOrPermanent(entity) && entity.model_type() == model_type) {
       sync_pb::SyncEntity sync_entity;
       entity.SerializeAsProto(&sync_entity);
       sync_entities.push_back(sync_entity);
     }
   }
   return sync_entities;
 }
 
 void FakeServer::InjectEntity(std::unique_ptr<FakeServerEntity> entity) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SaveEntity(std::move(entity));
 }
 
 bool FakeServer::ModifyEntitySpecifics(
     const std::string& id,
     const sync_pb::EntitySpecifics& updated_specifics) {
   EntityMap::const_iterator iter = entities_.find(id);
   if (iter == entities_.end() ||
-      iter->second->GetModelType() !=
+      iter->second->model_type() !=
           GetModelTypeFromSpecifics(updated_specifics)) {
     return false;
   }
 
   FakeServerEntity* entity = iter->second.get();
   entity->SetSpecifics(updated_specifics);
   UpdateEntityVersion(entity);
   return true;
 }
 
 bool FakeServer::ModifyBookmarkEntity(
     const std::string& id,
     const std::string& parent_id,
     const sync_pb::EntitySpecifics& updated_specifics) {
   EntityMap::const_iterator iter = entities_.find(id);
   if (iter == entities_.end() ||
-      iter->second->GetModelType() != syncer::BOOKMARKS ||
+      iter->second->model_type() != syncer::BOOKMARKS ||
       GetModelTypeFromSpecifics(updated_specifics) != syncer::BOOKMARKS) {
     return false;
   }
 
   BookmarkEntity* entity = static_cast<BookmarkEntity*>(iter->second.get());
 
   entity->SetParentId(parent_id);
   entity->SetSpecifics(updated_specifics);
   if (updated_specifics.has_bookmark()) {
     entity->SetName(updated_specifics.bookmark().title());
@@ skipping 94 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   network_enabled_ = false;
 }
 
 std::string FakeServer::GetBookmarkBarFolderId() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     FakeServerEntity* entity = it->second.get();
     if (entity->GetName() == kBookmarkBarFolderName && entity->IsFolder() &&
-        entity->GetModelType() == syncer::BOOKMARKS) {
-      return entity->GetId();
+        entity->model_type() == syncer::BOOKMARKS) {
+      return entity->id();
     }
   }
   NOTREACHED() << "Bookmark Bar entity not found.";
   return "";
 }
 
 base::WeakPtr<FakeServer> FakeServer::AsWeakPtr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 std::string FakeServer::GetStoreBirthday() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Int64ToString(store_birthday_);
 }
 
 }  // namespace fake_server