Convert Sync BirthdayErrorTest to use FakeServer

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>
@@ skipping 16 matching lines @@
 #include "sync/test/fake_server/tombstone_entity.h"
 #include "sync/test/fake_server/unique_client_entity.h"
 
 using std::string;
 using std::vector;
 
 using syncer::GetModelType;
 using syncer::ModelType;
 using syncer::ModelTypeSet;
 
-// The default birthday value.
-static const char kDefaultBirthday[] = "1234567890";
+// The default store birthday value.
+static const char kDefaultStoreBirthday[] = "1234567890";
 
 // The default keystore key.
 static const char kDefaultKeystoreKey[] = "1111111111111111";
 
 namespace fake_server {
 
 class FakeServerEntity;
 
 namespace {
 
@@ skipping 89 matching lines @@
     if (version < min_version)
       min_version = version;
   }
 
   return scoped_ptr<UpdateSieve>(
       new UpdateSieve(request_from_version, min_version));
 }
 
 }  // namespace
 
-FakeServer::FakeServer() : version_(0), birthday_(kDefaultBirthday) {
+FakeServer::FakeServer() : version_(0), store_birthday_(kDefaultStoreBirthday) {
   keystore_keys_.push_back(kDefaultKeystoreKey);
   CHECK(CreateDefaultPermanentItems());
 }
 
 FakeServer::~FakeServer() {
   STLDeleteContainerPairSecondPointers(entities_.begin(), entities_.end());
 }
 
 bool FakeServer::CreateDefaultPermanentItems() {
   ModelTypeSet all_types = syncer::ProtocolTypes();
@@ skipping 52 matching lines @@
   entity->SetVersion(++version_);
   entities_[entity->GetId()] = entity;
 }
 
 void FakeServer::HandleCommand(const string& request,
                                const HandleCommandCallback& callback) {
   sync_pb::ClientToServerMessage message;
   bool parsed = message.ParseFromString(request);
   DCHECK(parsed);
 
+  sync_pb::SyncEnums_ErrorType error_code;
   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(),
-                                    message.invalidator_client_id(),
-                                    response_proto.mutable_commit());
-      break;
-    default:
-      callback.Run(net::ERR_NOT_IMPLEMENTED, 0, string());;
+
+  if (message.has_store_birthday() &&
+      message.store_birthday() != store_birthday_) {
+    error_code = sync_pb::SyncEnums::NOT_MY_BIRTHDAY;
+  } else {
+    bool success;

[Nicolas Zea, 2014/06/02 22:02:04]

nit: initialize to false

[pval...(no longer on Chromium), 2014/06/02 23:06:54]

Done.

+    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(),
+                                      message.invalidator_client_id(),
+                                      response_proto.mutable_commit());
+        break;
+      default:
+        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.
+      callback.Run(net::ERR_FAILED, 0, string());
       return;
+    }
+
+    error_code = sync_pb::SyncEnums::SUCCESS;
   }
 
-  if (!success) {
-    // TODO(pvalenzuela): Add logging here so that tests have more info about
-    // the failure.
-    callback.Run(net::ERR_FAILED, 0, string());
-    return;
-  }
-
-  response_proto.set_error_code(sync_pb::SyncEnums::SUCCESS);
-  response_proto.set_store_birthday(birthday_);
+  response_proto.set_error_code(error_code);
+  response_proto.set_store_birthday(store_birthday_);
   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);
 
@@ skipping 209 matching lines @@
     list_value->Append(new base::StringValue(entity->GetName()));
   }
 
   return dictionary.Pass();
 }
 
 void FakeServer::InjectEntity(scoped_ptr<FakeServerEntity> entity) {
   SaveEntity(entity.release());
 }
 
+bool FakeServer::SetNewStoreBirthday(const string& store_birthday) {
+  if (store_birthday_ == store_birthday)
+    return false;
+
+  store_birthday_ = store_birthday;
+  return true;
+}
+
 void FakeServer::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeServer::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 }  // namespace fake_server