sync/test/engine/mock_connection_manager.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // Mock ServerConnectionManager class for use in client regression tests.
   6
   7 #include "sync/test/engine/mock_connection_manager.h"
   8
   9 #include <map>
  10
  11 #include "base/location.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "sync/engine/syncer_proto_util.h"
  14 #include "sync/protocol/bookmark_specifics.pb.h"
  15 #include "sync/syncable/directory.h"
  16 #include "sync/syncable/syncable_write_transaction.h"
  17 #include "sync/test/engine/test_id_factory.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using std::find;
  21 using std::map;
  22 using std::string;
  23 using sync_pb::ClientToServerMessage;
  24 using sync_pb::CommitMessage;
  25 using sync_pb::CommitResponse;
  26 using sync_pb::GetUpdatesMessage;
  27 using sync_pb::SyncEnums;
  28
  29 namespace syncer {
  30
  31 using syncable::WriteTransaction;
  32
  33 static char kValidAuthToken[] = "AuthToken";
  34 static char kCacheGuid[] = "kqyg7097kro6GSUod+GSg==";
  35
  36 MockConnectionManager::MockConnectionManager(syncable::Directory* directory,
  37                                              CancelationSignal* signal)
  38     : ServerConnectionManager("unused", 0, false, signal),
  39       server_reachable_(true),
  40       conflict_all_commits_(false),
  41       conflict_n_commits_(0),
  42       next_new_id_(10000),
  43       store_birthday_("Store BDay!"),
  44       store_birthday_sent_(false),
  45       client_stuck_(false),
  46       countdown_to_postbuffer_fail_(0),
  47       directory_(directory),
  48       mid_commit_observer_(NULL),
  49       throttling_(false),
  50       fail_with_auth_invalid_(false),
  51       fail_non_periodic_get_updates_(false),
  52       next_position_in_parent_(2),
  53       use_legacy_bookmarks_protocol_(false),
  54       num_get_updates_requests_(0) {
  55   SetNewTimestamp(0);
  56   SetAuthToken(kValidAuthToken);
  57 }
  58
  59 MockConnectionManager::~MockConnectionManager() {
  60   EXPECT_TRUE(update_queue_.empty()) << "Unfetched updates.";
  61 }
  62
  63 void MockConnectionManager::SetCommitTimeRename(string prepend) {
  64   commit_time_rename_prepended_string_ = prepend;
  65 }
  66
  67 void MockConnectionManager::SetMidCommitCallback(
  68     const base::Closure& callback) {
  69   mid_commit_callback_ = callback;
  70 }
  71
  72 void MockConnectionManager::SetMidCommitObserver(
  73     MockConnectionManager::MidCommitObserver* observer) {
  74     mid_commit_observer_ = observer;
  75 }
  76
  77 bool MockConnectionManager::PostBufferToPath(PostBufferParams* params,
  78     const string& path,
  79     const string& auth_token,
  80     ScopedServerStatusWatcher* watcher) {
  81   ClientToServerMessage post;
  82   CHECK(post.ParseFromString(params->buffer_in));
  83   CHECK(post.has_protocol_version());
  84   CHECK(post.has_api_key());
  85   CHECK(post.has_bag_of_chips());
  86
  87   requests_.push_back(post);
  88   client_stuck_ = post.sync_problem_detected();
  89   sync_pb::ClientToServerResponse response;
  90   response.Clear();
  91
  92   if (directory_) {
  93     // If the Directory's locked when we do this, it's a problem as in normal
  94     // use this function could take a while to return because it accesses the
  95     // network. As we can't test this we do the next best thing and hang here
  96     // when there's an issue.
  97     CHECK(directory_->good());
  98     WriteTransaction wt(FROM_HERE, syncable::UNITTEST, directory_);
  99   }
 100
 101   if (auth_token.empty()) {
 102     params->response.server_status = HttpResponse::SYNC_AUTH_ERROR;
 103     return false;
 104   }
 105
 106   if (auth_token != kValidAuthToken) {
 107     // Simulate server-side auth failure.
 108     params->response.server_status = HttpResponse::SYNC_AUTH_ERROR;
 109     InvalidateAndClearAuthToken();
 110   }
 111
 112   if (--countdown_to_postbuffer_fail_ == 0) {
 113     // Fail as countdown hits zero.
 114     params->response.server_status = HttpResponse::SYNC_SERVER_ERROR;
 115     return false;
 116   }
 117
 118   if (!server_reachable_) {
 119     params->response.server_status = HttpResponse::CONNECTION_UNAVAILABLE;
 120     return false;
 121   }
 122
 123   // Default to an ok connection.
 124   params->response.server_status = HttpResponse::SERVER_CONNECTION_OK;
 125   response.set_error_code(SyncEnums::SUCCESS);
 126   const string current_store_birthday = store_birthday();
 127   response.set_store_birthday(current_store_birthday);
 128   if (post.has_store_birthday() && post.store_birthday() !=
 129       current_store_birthday) {
 130     response.set_error_code(SyncEnums::NOT_MY_BIRTHDAY);
 131     response.set_error_message("Merry Unbirthday!");
 132     response.SerializeToString(&params->buffer_out);
 133     store_birthday_sent_ = true;
 134     return true;
 135   }
 136   bool result = true;
 137   EXPECT_TRUE(!store_birthday_sent_ || post.has_store_birthday() ||
 138               post.message_contents() == ClientToServerMessage::AUTHENTICATE);
 139   store_birthday_sent_ = true;
 140
 141   if (post.message_contents() == ClientToServerMessage::COMMIT) {
 142     ProcessCommit(&post, &response);
 143   } else if (post.message_contents() == ClientToServerMessage::GET_UPDATES) {
 144     ProcessGetUpdates(&post, &response);
 145   } else {
 146     EXPECT_TRUE(false) << "Unknown/unsupported ClientToServerMessage";
 147     return false;
 148   }
 149
 150   {
 151     base::AutoLock lock(response_code_override_lock_);
 152     if (throttling_) {
 153       response.set_error_code(SyncEnums::THROTTLED);
 154       throttling_ = false;
 155     }
 156
 157     if (fail_with_auth_invalid_)
 158       response.set_error_code(SyncEnums::AUTH_INVALID);
 159   }
 160
 161   response.SerializeToString(&params->buffer_out);
 162   if (post.message_contents() == ClientToServerMessage::COMMIT &&
 163       !mid_commit_callback_.is_null()) {
 164     mid_commit_callback_.Run();
 165     mid_commit_callback_.Reset();
 166   }
 167   if (mid_commit_observer_) {
 168     mid_commit_observer_->Observe();
 169   }
 170
 171   return result;
 172 }
 173
 174 sync_pb::GetUpdatesResponse* MockConnectionManager::GetUpdateResponse() {
 175   if (update_queue_.empty()) {
 176     NextUpdateBatch();
 177   }
 178   return &update_queue_.back();
 179 }
 180
 181 void MockConnectionManager::AddDefaultBookmarkData(sync_pb::SyncEntity* entity,
 182                                                    bool is_folder) {
 183   if (use_legacy_bookmarks_protocol_) {
 184     sync_pb::SyncEntity_BookmarkData* data = entity->mutable_bookmarkdata();
 185     data->set_bookmark_folder(is_folder);
 186
 187     if (!is_folder) {
 188       data->set_bookmark_url("http://google.com");
 189     }
 190   } else {
 191     entity->set_folder(is_folder);
 192     entity->mutable_specifics()->mutable_bookmark();
 193     if (!is_folder) {
 194       entity->mutable_specifics()->mutable_bookmark()->
 195           set_url("http://google.com");
 196     }
 197   }
 198 }
 199
 200 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
 201     int id,
 202     int parent_id,
 203     string name,
 204     int64 version,
 205     int64 sync_ts,
 206     std::string originator_cache_guid,
 207     std::string originator_client_item_id) {
 208   return AddUpdateDirectory(TestIdFactory::FromNumber(id),
 209                             TestIdFactory::FromNumber(parent_id),
 210                             name,
 211                             version,
 212                             sync_ts,
 213                             originator_cache_guid,
 214                             originator_client_item_id);
 215 }
 216
 217 void MockConnectionManager::SetGUClientCommand(
 218     sync_pb::ClientCommand* command) {
 219   gu_client_command_.reset(command);
 220 }
 221
 222 void MockConnectionManager::SetCommitClientCommand(
 223     sync_pb::ClientCommand* command) {
 224   commit_client_command_.reset(command);
 225 }
 226
 227 void MockConnectionManager::SetTransientErrorId(syncable::Id id) {
 228   transient_error_ids_.push_back(id);
 229 }
 230
 231 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
 232     int id, int parent_id,
 233     string name, int64 version,
 234     int64 sync_ts,
 235     string originator_client_item_id,
 236     string originator_cache_guid) {
 237   return AddUpdateBookmark(TestIdFactory::FromNumber(id),
 238                            TestIdFactory::FromNumber(parent_id),
 239                            name,
 240                            version,
 241                            sync_ts,
 242                            originator_client_item_id,
 243                            originator_cache_guid);
 244 }
 245
 246 sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
 247     int id,
 248     int parent_id,
 249     string name,
 250     int64 version,
 251     int64 sync_ts,
 252     bool is_dir,
 253     int64 position,
 254     const sync_pb::EntitySpecifics& specifics) {
 255   sync_pb::SyncEntity* ent = AddUpdateMeta(
 256       TestIdFactory::FromNumber(id).GetServerId(),
 257       TestIdFactory::FromNumber(parent_id).GetServerId(),
 258       name, version, sync_ts);
 259   ent->set_position_in_parent(position);
 260   ent->mutable_specifics()->CopyFrom(specifics);
 261   ent->set_folder(is_dir);
 262   return ent;
 263 }
 264
 265 sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
 266     int id,
 267     int parent_id,
 268     string name,
 269     int64 version,
 270     int64 sync_ts,
 271     bool is_dir,
 272     int64 position,
 273     const sync_pb::EntitySpecifics& specifics,
 274     string originator_cache_guid,
 275     string originator_client_item_id) {
 276   sync_pb::SyncEntity* ent = AddUpdateSpecifics(
 277       id, parent_id, name, version, sync_ts, is_dir, position, specifics);
 278   ent->set_originator_cache_guid(originator_cache_guid);
 279   ent->set_originator_client_item_id(originator_client_item_id);
 280   return ent;
 281 }
 282
 283 sync_pb::SyncEntity* MockConnectionManager::SetNigori(
 284     int id,
 285     int64 version,
 286     int64 sync_ts,
 287     const sync_pb::EntitySpecifics& specifics) {
 288   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
 289   ent->set_id_string(TestIdFactory::FromNumber(id).GetServerId());
 290   ent->set_parent_id_string(TestIdFactory::FromNumber(0).GetServerId());
 291   ent->set_server_defined_unique_tag(ModelTypeToRootTag(NIGORI));
 292   ent->set_name("Nigori");
 293   ent->set_non_unique_name("Nigori");
 294   ent->set_version(version);
 295   ent->set_sync_timestamp(sync_ts);
 296   ent->set_mtime(sync_ts);
 297   ent->set_ctime(1);
 298   ent->set_position_in_parent(0);
 299   ent->set_folder(false);
 300   ent->mutable_specifics()->CopyFrom(specifics);
 301   return ent;
 302 }
 303
 304 sync_pb::SyncEntity* MockConnectionManager::AddUpdatePref(string id,
 305                                                           string parent_id,
 306                                                           string client_tag,
 307                                                           int64 version,
 308                                                           int64 sync_ts) {
 309   sync_pb::SyncEntity* ent =
 310       AddUpdateMeta(id, parent_id, " ", version, sync_ts);
 311
 312   ent->set_client_defined_unique_tag(client_tag);
 313
 314   sync_pb::EntitySpecifics specifics;
 315   AddDefaultFieldValue(PREFERENCES, &specifics);
 316   ent->mutable_specifics()->CopyFrom(specifics);
 317
 318   return ent;
 319 }
 320
 321 sync_pb::SyncEntity* MockConnectionManager::AddUpdateFull(
 322     string id, string parent_id,
 323     string name, int64 version,
 324     int64 sync_ts, bool is_dir) {
 325   sync_pb::SyncEntity* ent =
 326       AddUpdateMeta(id, parent_id, name, version, sync_ts);
 327   AddDefaultBookmarkData(ent, is_dir);
 328   return ent;
 329 }
 330
 331 sync_pb::SyncEntity* MockConnectionManager::AddUpdateMeta(
 332     string id, string parent_id,
 333     string name, int64 version,
 334     int64 sync_ts) {
 335   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
 336   ent->set_id_string(id);
 337   ent->set_parent_id_string(parent_id);
 338   ent->set_non_unique_name(name);
 339   ent->set_name(name);
 340   ent->set_version(version);
 341   ent->set_sync_timestamp(sync_ts);
 342   ent->set_mtime(sync_ts);
 343   ent->set_ctime(1);
 344   ent->set_position_in_parent(GeneratePositionInParent());
 345
 346   // This isn't perfect, but it works well enough.  This is an update, which
 347   // means the ID is a server ID, which means it never changes.  By making
 348   // kCacheGuid also never change, we guarantee that the same item always has
 349   // the same originator_cache_guid and originator_client_item_id.
 350   //
 351   // Unfortunately, neither this class nor the tests that use it explicitly
 352   // track sync entitites, so supporting proper cache guids and client item IDs
 353   // would require major refactoring.  The ID used here ought to be the "c-"
 354   // style ID that was sent up on the commit.
 355   ent->set_originator_cache_guid(kCacheGuid);
 356   ent->set_originator_client_item_id(id);
 357
 358   return ent;
 359 }
 360
 361 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
 362     string id,
 363     string parent_id,
 364     string name,
 365     int64 version,
 366     int64 sync_ts,
 367     std::string originator_cache_guid,
 368     std::string originator_client_item_id) {
 369   sync_pb::SyncEntity* ret =
 370       AddUpdateFull(id, parent_id, name, version, sync_ts, true);
 371   ret->set_originator_cache_guid(originator_cache_guid);
 372   ret->set_originator_client_item_id(originator_client_item_id);
 373   return ret;
 374 }
 375
 376 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
 377     string id,
 378     string parent_id,
 379     string name, int64 version,
 380     int64 sync_ts,
 381     string originator_cache_guid,
 382     string originator_client_item_id) {
 383   sync_pb::SyncEntity* ret =
 384       AddUpdateFull(id, parent_id, name, version, sync_ts, false);
 385   ret->set_originator_cache_guid(originator_cache_guid);
 386   ret->set_originator_client_item_id(originator_client_item_id);
 387   return ret;
 388 }
 389
 390 sync_pb::SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
 391   EXPECT_EQ(1, last_sent_commit().entries_size());
 392   EXPECT_EQ(1, last_commit_response().entryresponse_size());
 393   EXPECT_EQ(CommitResponse::SUCCESS,
 394       last_commit_response().entryresponse(0).response_type());
 395
 396   if (last_sent_commit().entries(0).deleted()) {
 397     AddUpdateTombstone(syncable::Id::CreateFromServerId(
 398         last_sent_commit().entries(0).id_string()));
 399   } else {
 400     sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
 401     ent->CopyFrom(last_sent_commit().entries(0));
 402     ent->clear_insert_after_item_id();
 403     ent->clear_old_parent_id();
 404     ent->set_position_in_parent(
 405         last_commit_response().entryresponse(0).position_in_parent());
 406     ent->set_version(
 407         last_commit_response().entryresponse(0).version());
 408     ent->set_id_string(
 409         last_commit_response().entryresponse(0).id_string());
 410
 411     // This is the same hack as in AddUpdateMeta.  See the comment in that
 412     // function for more information.
 413     ent->set_originator_cache_guid(kCacheGuid);
 414     ent->set_originator_client_item_id(
 415         last_commit_response().entryresponse(0).id_string());
 416
 417     if (last_sent_commit().entries(0).has_unique_position()) {
 418       ent->mutable_unique_position()->CopyFrom(
 419           last_sent_commit().entries(0).unique_position());
 420     }
 421
 422     // Tests don't currently care about the following:
 423     // parent_id_string, name, non_unique_name.
 424   }
 425   return GetMutableLastUpdate();
 426 }
 427
 428 void MockConnectionManager::AddUpdateTombstone(const syncable::Id& id) {
 429   // Tombstones have only the ID set and dummy values for the required fields.
 430   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
 431   ent->set_id_string(id.GetServerId());
 432   ent->set_version(0);
 433   ent->set_name("");
 434   ent->set_deleted(true);
 435
 436   // Make sure we can still extract the ModelType from this tombstone.
 437   ent->mutable_specifics()->mutable_bookmark();
 438 }
 439
 440 void MockConnectionManager::SetLastUpdateDeleted() {
 441   // Tombstones have only the ID set.  Wipe anything else.
 442   string id_string = GetMutableLastUpdate()->id_string();
 443   GetUpdateResponse()->mutable_entries()->RemoveLast();
 444   AddUpdateTombstone(syncable::Id::CreateFromServerId(id_string));
 445 }
 446
 447 void MockConnectionManager::SetLastUpdateOriginatorFields(
 448     const string& client_id,
 449     const string& entry_id) {
 450   GetMutableLastUpdate()->set_originator_cache_guid(client_id);
 451   GetMutableLastUpdate()->set_originator_client_item_id(entry_id);
 452 }
 453
 454 void MockConnectionManager::SetLastUpdateServerTag(const string& tag) {
 455   GetMutableLastUpdate()->set_server_defined_unique_tag(tag);
 456 }
 457
 458 void MockConnectionManager::SetLastUpdateClientTag(const string& tag) {
 459   GetMutableLastUpdate()->set_client_defined_unique_tag(tag);
 460 }
 461
 462 void MockConnectionManager::SetLastUpdatePosition(int64 server_position) {
 463   GetMutableLastUpdate()->set_position_in_parent(server_position);
 464 }
 465
 466 void MockConnectionManager::SetNewTimestamp(int ts) {
 467   next_token_ = base::StringPrintf("mock connection ts = %d", ts);
 468   ApplyToken();
 469 }
 470
 471 void MockConnectionManager::ApplyToken() {
 472   if (!update_queue_.empty()) {
 473     GetUpdateResponse()->clear_new_progress_marker();
 474     sync_pb::DataTypeProgressMarker* new_marker =
 475         GetUpdateResponse()->add_new_progress_marker();
 476     new_marker->set_data_type_id(-1);  // Invalid -- clients shouldn't see.
 477     new_marker->set_token(next_token_);
 478   }
 479 }
 480
 481 void MockConnectionManager::SetChangesRemaining(int64 timestamp) {
 482   GetUpdateResponse()->set_changes_remaining(timestamp);
 483 }
 484
 485 void MockConnectionManager::ProcessGetUpdates(
 486     sync_pb::ClientToServerMessage* csm,
 487     sync_pb::ClientToServerResponse* response) {
 488   CHECK(csm->has_get_updates());
 489   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::GET_UPDATES);
 490   const GetUpdatesMessage& gu = csm->get_updates();
 491   num_get_updates_requests_++;
 492   EXPECT_FALSE(gu.has_from_timestamp());
 493   EXPECT_FALSE(gu.has_requested_types());
 494
 495   if (fail_non_periodic_get_updates_) {
 496     EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::PERIODIC,
 497               gu.caller_info().source());
 498   }
 499
 500   // Verify that the items we're about to send back to the client are of
 501   // the types requested by the client.  If this fails, it probably indicates
 502   // a test bug.
 503   EXPECT_TRUE(gu.fetch_folders());
 504   EXPECT_FALSE(gu.has_requested_types());
 505   if (update_queue_.empty()) {
 506     GetUpdateResponse();
 507   }
 508   sync_pb::GetUpdatesResponse* updates = &update_queue_.front();
 509   for (int i = 0; i < updates->entries_size(); ++i) {
 510     if (!updates->entries(i).deleted()) {
 511       ModelType entry_type = GetModelType(updates->entries(i));
 512       EXPECT_TRUE(
 513           IsModelTypePresentInSpecifics(gu.from_progress_marker(), entry_type))
 514           << "Syncer did not request updates being provided by the test.";
 515     }
 516   }
 517
 518   response->mutable_get_updates()->CopyFrom(*updates);
 519
 520   // Set appropriate progress markers, overriding the value squirreled
 521   // away by ApplyToken().
 522   std::string token = response->get_updates().new_progress_marker(0).token();
 523   response->mutable_get_updates()->clear_new_progress_marker();
 524   for (int i = 0; i < gu.from_progress_marker_size(); ++i) {
 525     sync_pb::DataTypeProgressMarker* new_marker =
 526         response->mutable_get_updates()->add_new_progress_marker();
 527     new_marker->set_data_type_id(gu.from_progress_marker(i).data_type_id());
 528     new_marker->set_token(token);
 529   }
 530
 531   // Fill the keystore key if requested.
 532   if (gu.need_encryption_key())
 533     response->mutable_get_updates()->add_encryption_keys(keystore_key_);
 534
 535   update_queue_.pop_front();
 536
 537   if (gu_client_command_) {
 538     response->mutable_client_command()->CopyFrom(*gu_client_command_.get());
 539   }
 540 }
 541
 542 void MockConnectionManager::SetKeystoreKey(const std::string& key) {
 543   // Note: this is not a thread-safe set, ok for now.  NOT ok if tests
 544   // run the syncer on the background thread while this method is called.
 545   keystore_key_ = key;
 546 }
 547
 548 bool MockConnectionManager::ShouldConflictThisCommit() {
 549   bool conflict = false;
 550   if (conflict_all_commits_) {
 551     conflict = true;
 552   } else if (conflict_n_commits_ > 0) {
 553     conflict = true;
 554     --conflict_n_commits_;
 555   }
 556   return conflict;
 557 }
 558
 559 bool MockConnectionManager::ShouldTransientErrorThisId(syncable::Id id) {
 560   return find(transient_error_ids_.begin(), transient_error_ids_.end(), id)
 561       != transient_error_ids_.end();
 562 }
 563
 564 void MockConnectionManager::ProcessCommit(
 565     sync_pb::ClientToServerMessage* csm,
 566     sync_pb::ClientToServerResponse* response_buffer) {
 567   CHECK(csm->has_commit());
 568   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::COMMIT);
 569   map <string, string> changed_ids;
 570   const CommitMessage& commit_message = csm->commit();
 571   CommitResponse* commit_response = response_buffer->mutable_commit();
 572   commit_messages_.push_back(new CommitMessage);
 573   commit_messages_.back()->CopyFrom(commit_message);
 574   map<string, sync_pb::CommitResponse_EntryResponse*> response_map;
 575   for (int i = 0; i < commit_message.entries_size() ; i++) {
 576     const sync_pb::SyncEntity& entry = commit_message.entries(i);
 577     CHECK(entry.has_id_string());
 578     string id_string = entry.id_string();
 579     ASSERT_LT(entry.name().length(), 256ul) << " name probably too long. True "
 580         "server name checking not implemented";
 581     syncable::Id id;
 582     if (entry.version() == 0) {
 583       // Relies on our new item string id format. (string representation of a
 584       // negative number).
 585       id = syncable::Id::CreateFromClientString(id_string);
 586     } else {
 587       id = syncable::Id::CreateFromServerId(id_string);
 588     }
 589     committed_ids_.push_back(id);
 590
 591     if (response_map.end() == response_map.find(id_string))
 592       response_map[id_string] = commit_response->add_entryresponse();
 593     sync_pb::CommitResponse_EntryResponse* er = response_map[id_string];
 594     if (ShouldConflictThisCommit()) {
 595       er->set_response_type(CommitResponse::CONFLICT);
 596       continue;
 597     }
 598     if (ShouldTransientErrorThisId(id)) {
 599       er->set_response_type(CommitResponse::TRANSIENT_ERROR);
 600       continue;
 601     }
 602     er->set_response_type(CommitResponse::SUCCESS);
 603     er->set_version(entry.version() + 1);
 604     if (!commit_time_rename_prepended_string_.empty()) {
 605       // Commit time rename sent down from the server.
 606       er->set_name(commit_time_rename_prepended_string_ + entry.name());
 607     }
 608     string parent_id_string = entry.parent_id_string();
 609     // Remap id's we've already assigned.
 610     if (changed_ids.end() != changed_ids.find(parent_id_string)) {
 611       parent_id_string = changed_ids[parent_id_string];
 612       er->set_parent_id_string(parent_id_string);
 613     }
 614     if (entry.has_version() && 0 != entry.version()) {
 615       er->set_id_string(id_string);  // Allows verification.
 616     } else {
 617       string new_id = base::StringPrintf("mock_server:%d", next_new_id_++);
 618       changed_ids[id_string] = new_id;
 619       er->set_id_string(new_id);
 620     }
 621   }
 622   commit_responses_.push_back(new CommitResponse(*commit_response));
 623
 624   if (commit_client_command_) {
 625     response_buffer->mutable_client_command()->CopyFrom(
 626         *commit_client_command_.get());
 627   }
 628 }
 629
 630 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
 631     syncable::Id id,
 632     syncable::Id parent_id,
 633     string name,
 634     int64 version,
 635     int64 sync_ts,
 636     string originator_cache_guid,
 637     string originator_client_item_id) {
 638   return AddUpdateDirectory(id.GetServerId(), parent_id.GetServerId(),
 639                             name, version, sync_ts, originator_cache_guid,
 640                             originator_client_item_id);
 641 }
 642
 643 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
 644     syncable::Id id,
 645     syncable::Id parent_id,
 646     string name,
 647     int64 version,
 648     int64 sync_ts,
 649     string originator_cache_guid,
 650     string originator_client_item_id) {
 651   return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(),
 652                            name, version, sync_ts, originator_cache_guid,
 653                            originator_client_item_id);
 654 }
 655
 656 sync_pb::SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
 657   sync_pb::GetUpdatesResponse* updates = GetUpdateResponse();
 658   EXPECT_GT(updates->entries_size(), 0);
 659   return updates->mutable_entries()->Mutable(updates->entries_size() - 1);
 660 }
 661
 662 void MockConnectionManager::NextUpdateBatch() {
 663   update_queue_.push_back(sync_pb::GetUpdatesResponse::default_instance());
 664   SetChangesRemaining(0);
 665   ApplyToken();
 666 }
 667
 668 const CommitMessage& MockConnectionManager::last_sent_commit() const {
 669   EXPECT_TRUE(!commit_messages_.empty());
 670   return *commit_messages_.back();
 671 }
 672
 673 const CommitResponse& MockConnectionManager::last_commit_response() const {
 674   EXPECT_TRUE(!commit_responses_.empty());
 675   return *commit_responses_.back();
 676 }
 677
 678 const sync_pb::ClientToServerMessage&
 679     MockConnectionManager::last_request() const {
 680   EXPECT_TRUE(!requests_.empty());
 681   return requests_.back();
 682 }
 683
 684 const std::vector<sync_pb::ClientToServerMessage>&
 685     MockConnectionManager::requests() const {
 686   return requests_;
 687 }
 688
 689 bool MockConnectionManager::IsModelTypePresentInSpecifics(
 690     const google::protobuf::RepeatedPtrField<
 691         sync_pb::DataTypeProgressMarker>& filter,
 692     ModelType value) {
 693   int data_type_id = GetSpecificsFieldNumberFromModelType(value);
 694   for (int i = 0; i < filter.size(); ++i) {
 695     if (filter.Get(i).data_type_id() == data_type_id) {
 696       return true;
 697     }
 698   }
 699   return false;
 700 }
 701
 702 sync_pb::DataTypeProgressMarker const*
 703     MockConnectionManager::GetProgressMarkerForType(
 704         const google::protobuf::RepeatedPtrField<
 705             sync_pb::DataTypeProgressMarker>& filter,
 706         ModelType value) {
 707   int data_type_id = GetSpecificsFieldNumberFromModelType(value);
 708   for (int i = 0; i < filter.size(); ++i) {
 709     if (filter.Get(i).data_type_id() == data_type_id) {
 710       return &(filter.Get(i));
 711     }
 712   }
 713   return NULL;
 714 }
 715
 716 void MockConnectionManager::SetServerReachable() {
 717   server_reachable_ = true;
 718 }
 719
 720 void MockConnectionManager::SetServerNotReachable() {
 721   server_reachable_ = false;
 722 }
 723
 724 void MockConnectionManager::UpdateConnectionStatus() {
 725   if (!server_reachable_) {
 726     server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
 727   } else {
 728     server_status_ = HttpResponse::SERVER_CONNECTION_OK;
 729   }
 730 }
 731
 732 void MockConnectionManager::SetServerStatus(
 733     HttpResponse::ServerConnectionCode server_status) {
 734   server_status_ = server_status;
 735 }
 736
 737 }  // namespace syncer