Use FakeServer-based invalidations for Sync tests (try #2)

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 "sync/test/fake_server/fake_server.h"
 
+#include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/test/fake_server/bookmark_entity.h"
 #include "sync/test/fake_server/permanent_entity.h"
 #include "sync/test/fake_server/tombstone_entity.h"
 #include "sync/test/fake_server/unique_client_entity.h"
 
 using std::string;
 using std::vector;
 
-using base::AutoLock;
 using syncer::GetModelType;
 using syncer::ModelType;
 using syncer::ModelTypeSet;
 
 // The default birthday value.
 static const char kDefaultBirthday[] = "1234567890";
 
 // The default keystore key.
 static const char kDefaultKeystoreKey[] = "1111111111111111";
 
@@ skipping 188 matching lines @@
   SaveEntity(mobile_bookmarks_entity);
   return true;
 }
 
 void FakeServer::SaveEntity(FakeServerEntity* entity) {
   delete entities_[entity->GetId()];
   entity->SetVersion(++version_);
   entities_[entity->GetId()] = entity;
 }
 
-int FakeServer::HandleCommand(const string& request,
-                              int* response_code,
-                              string* response) {
-  AutoLock lock(lock_);
-
+void FakeServer::HandleCommand(const string& request,
+                               const HandleCommandCallback& callback) {
   sync_pb::ClientToServerMessage message;
   bool parsed = message.ParseFromString(request);
   DCHECK(parsed);
 
   sync_pb::ClientToServerResponse response_proto;
   bool success;
   switch (message.message_contents()) {
     case sync_pb::ClientToServerMessage::GET_UPDATES:
       success = HandleGetUpdatesRequest(message.get_updates(),
                                         response_proto.mutable_get_updates());
       break;
     case sync_pb::ClientToServerMessage::COMMIT:
       success = HandleCommitRequest(message.commit(),
                                     response_proto.mutable_commit());
       break;
     default:
-      return net::ERR_NOT_IMPLEMENTED;
+      callback.Run(net::ERR_NOT_IMPLEMENTED, 0, string());;
+      return;
   }
 
   if (!success) {
     // TODO(pvalenzuela): Add logging here so that tests have more info about
     // the failure.
-    return net::HTTP_BAD_REQUEST;
+    callback.Run(net::ERR_FAILED, 0, string());
+    return;
   }
 
   response_proto.set_error_code(sync_pb::SyncEnums::SUCCESS);
   response_proto.set_store_birthday(birthday_);
-  *response_code = net::HTTP_OK;
-  *response = response_proto.SerializeAsString();
-  return 0;
+  callback.Run(0, net::HTTP_OK, response_proto.SerializeAsString());
 }
 
 bool FakeServer::HandleGetUpdatesRequest(
     const sync_pb::GetUpdatesMessage& get_updates,
     sync_pb::GetUpdatesResponse* response) {
   // TODO(pvalenzuela): Implement batching instead of sending all information
   // at once.
   response->set_changes_remaining(0);
 
   scoped_ptr<UpdateSieve> sieve = UpdateSieve::Create(get_updates);
@@ skipping 31 matching lines @@
     for (vector<string>::iterator it = keystore_keys_.begin();
          it != keystore_keys_.end(); ++it) {
       response->add_encryption_keys(*it);
     }
   }
 
   sieve->UpdateProgressMarkers(max_response_version, response);
   return true;
 }
 
-bool FakeServer::CommitEntity(
+string FakeServer::CommitEntity(
     const sync_pb::SyncEntity& client_entity,
     sync_pb::CommitResponse_EntryResponse* entry_response,
     string client_guid,
-    std::map<string, string>* client_to_server_ids) {
+    string parent_id) {
   if (client_entity.version() == 0 && client_entity.deleted()) {
-    return false;
+    return string();
   }
 
   FakeServerEntity* entity;
   if (client_entity.deleted()) {
     entity = TombstoneEntity::Create(client_entity.id_string());
     // TODO(pvalenzuela): Change the behavior of DeleteChilden so that it does
     // not modify server data if it fails.
     if (!DeleteChildren(client_entity.id_string())) {
-      return false;
+      return string();
     }
   } else if (GetModelType(client_entity) == syncer::NIGORI) {
     // NIGORI is the only permanent item type that should be updated by the
     // client.
     entity = PermanentEntity::CreateUpdatedNigoriEntity(
         client_entity,
         entities_[client_entity.id_string()]);
   } else if (client_entity.has_client_defined_unique_tag()) {
     if (entities_.find(client_entity.id_string()) != entities_.end()) {
       entity = UniqueClientEntity::CreateUpdatedVersion(
           client_entity,
           entities_[client_entity.id_string()]);
     } else {
       entity = UniqueClientEntity::CreateNew(client_entity);
     }
   } else {
-    string parent_id = client_entity.parent_id_string();
-    if (client_to_server_ids->find(parent_id) !=
-        client_to_server_ids->end()) {
-      parent_id = (*client_to_server_ids)[parent_id];
-    }
     // TODO(pvalenzuela): Validate entity's parent ID.
     if (entities_.find(client_entity.id_string()) != entities_.end()) {
       entity = BookmarkEntity::CreateUpdatedVersion(
         client_entity,
         entities_[client_entity.id_string()],
         parent_id);
     } else {
       entity = BookmarkEntity::CreateNew(client_entity, parent_id, client_guid);
     }
   }
 
   if (entity == NULL) {
     // TODO(pvalenzuela): Add logging so that it is easier to determine why
     // creation failed.
-    return false;
-  }
-
-  // Record the ID if it was renamed.
-  if (client_entity.id_string() != entity->GetId()) {
-    (*client_to_server_ids)[client_entity.id_string()] = entity->GetId();
+    return string();
   }
 
   SaveEntity(entity);
   BuildEntryResponseForSuccessfulCommit(entry_response, entity);
-  return true;
+  return entity->GetId();
 }
 
 void FakeServer::BuildEntryResponseForSuccessfulCommit(
   sync_pb::CommitResponse_EntryResponse* entry_response,
   FakeServerEntity* entity) {
     entry_response->set_response_type(sync_pb::CommitResponse::SUCCESS);
     entry_response->set_id_string(entity->GetId());
 
     if (entity->IsDeleted()) {
       entry_response->set_version(entity->GetVersion() + 1);
@@ skipping 36 matching lines @@
   }
 
   return true;
 }
 
 bool FakeServer::HandleCommitRequest(
     const sync_pb::CommitMessage& commit,
     sync_pb::CommitResponse* response) {
   std::map<string, string> client_to_server_ids;
   string guid = commit.cache_guid();
+  ModelTypeSet committed_model_types;
 
   // TODO(pvalenzuela): Add validation of CommitMessage.entries.
   ::google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>::const_iterator it;
   for (it = commit.entries().begin(); it != commit.entries().end(); ++it) {
     sync_pb::CommitResponse_EntryResponse* entry_response =
         response->add_entryresponse();
 
-    if (!CommitEntity(*it, entry_response, guid, &client_to_server_ids)) {
+    sync_pb::SyncEntity client_entity = *it;
+    string parent_id = client_entity.parent_id_string();
+    if (client_to_server_ids.find(parent_id) !=
+        client_to_server_ids.end()) {
+      parent_id = client_to_server_ids[parent_id];
+    }
+
+    string entity_id = CommitEntity(client_entity,
+                                    entry_response,
+                                    guid,
+                                    parent_id);
+    if (entity_id.empty()) {
       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;
+    }
+    FakeServerEntity* entity = entities_[entity_id];
+    committed_model_types.Put(entity->GetModelType());
   }
 
+  FOR_EACH_OBSERVER(Observer, observers_, OnCommit(committed_model_types));
   return true;
 }
 
 scoped_ptr<base::DictionaryValue> FakeServer::GetEntitiesAsDictionaryValue() {
   scoped_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());
@@ skipping 15 matching lines @@
     }
     // 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->Append(new base::StringValue(entity->GetName()));
   }
 
   return dictionary.Pass();
 }
 
+void FakeServer::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void FakeServer::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 }  // namespace fake_server