Add integraton test for sync backup/rollback.

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 127 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),
+                           birthday_(kDefaultBirthday),
+                           error_type_(sync_pb::SyncEnums::SUCCESS) {
   keystore_keys_.push_back(kDefaultKeystoreKey);
   CHECK(CreateDefaultPermanentItems());
 }
 
 FakeServer::~FakeServer() {
   STLDeleteContainerPairSecondPointers(entities_.begin(), entities_.end());
 }
 
 bool FakeServer::CreateDefaultPermanentItems() {
   ModelTypeSet all_types = syncer::ProtocolTypes();
@@ skipping 54 matching lines @@
 }
 
 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(),
-                                    message.invalidator_client_id(),
-                                    response_proto.mutable_commit());
-      break;
-    default:
-      callback.Run(net::ERR_NOT_IMPLEMENTED, 0, string());;
-      return;
+
+  if (error_type_ != sync_pb::SyncEnums::SUCCESS) {

[pval...(no longer on Chromium), 2014/06/03 22:08:18]

there are a few other in-flight changes here that might make merging difficult.
would you like me to commit the TriggerError infrastructure so that you don't
have to deal with it?

[haitaol1, 2014/06/04 18:21:30]

I rebased on ToT. Please take a look to verify.

On 2014/06/03 22:08:18, pvalenzuela wrote:

[pval...(no longer on Chromium), 2014/06/05 17:46:14]

latest version (patchset 5) looks good

+    success = true;
+  } else {
+    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;
   }
 
-  response_proto.set_error_code(sync_pb::SyncEnums::SUCCESS);
   response_proto.set_store_birthday(birthday_);
+  response_proto.set_error_code(error_type_);
   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());
 }
 
+void FakeServer::TriggerError(const sync_pb::SyncEnums::ErrorType& error_type) {

[rlarocque, 2014/06/03 22:59:48]

I think we should look at mock_connection_manager.cc and take it as a warning. 
This style of injecting errors works when there's one or two conditions we care
about, but it can eventually lead to a hairball once we have many different
conditions and triggering logic.

This is OK for now, but we should keep an eye on this style of error injection
to make sure it doesn't get out of control.

[haitaol1, 2014/06/04 18:21:30]

Added a todo for Patrick.

On 2014/06/03 22:59:48, rlarocque wrote:

[pval...(no longer on Chromium), 2014/06/05 17:46:14]

Great; thanks for TODO. I'll clean this up in a later CL.

+  error_type_ = error_type;
+}
+
 void FakeServer::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeServer::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 }  // namespace fake_server