Use FakeServer-based invalidations for Sync tests

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";
 
 namespace fake_server {
 
 class FakeServerEntity;
@@ skipping 185 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 base::Closure& callback,
+                               int* error_code,
+                               int* response_code,
+                               string* response) {
   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;
+      *error_code = net::ERR_NOT_IMPLEMENTED;
+      callback.Run();
+      return;
   }
 
   if (!success) {
     // TODO(pvalenzuela): Add logging here so that tests have more info about
     // the failure.
-    return net::HTTP_BAD_REQUEST;

[pval...(no longer on Chromium), 2014/04/24 01:08:53]

this value was incorrect (it's the error code, not an HTTP response code)

+    *error_code = net::HTTP_BAD_REQUEST;
+    callback.Run();
+    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;
+  *error_code = 0;
+  callback.Run();
 }
 
 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 35 matching lines @@
   }
 
   sieve->UpdateProgressMarkers(max_response_version, response);
   return true;
 }
 
 bool FakeServer::CommitEntity(
     const sync_pb::SyncEntity& client_entity,
     sync_pb::CommitResponse_EntryResponse* entry_response,
     string client_guid,
+    ModelType* model_type,

[rlarocque, 2014/04/22 18:22:22]

This is starting to look a little awkward.  Could you just return the server ID
of the saved entity instead?  That way you could populate the
client_to_server_ids map and fetch the ModelType from the caller.

That may or may not be cleaner.  Let me know what you think.

[pval...(no longer on Chromium), 2014/04/24 01:08:53]

done / looks good to me

     std::map<string, string>* client_to_server_ids) {
   if (client_entity.version() == 0 && client_entity.deleted()) {
     return false;
   }
 
   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.
@@ skipping 37 matching lines @@
     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();
   }
 
   SaveEntity(entity);
   BuildEntryResponseForSuccessfulCommit(entry_response, entity);
+  *model_type = entity->GetModelType();
   return true;
 }
 
 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()) {
@@ skipping 37 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)) {
+    ModelType model_type;
+    if (!CommitEntity(*it,
+                      entry_response,
+                      guid,
+                      &model_type,
+                      &client_to_server_ids)) {
       return false;
     }
+    committed_model_types.Put(model_type);
   }
 
+  FOR_EACH_OBSERVER(Observer, observers_, OnCommit(committed_model_types));
   return true;
 }
 
+void FakeServer::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
 }  // namespace fake_server