Fix handling of undeletion within the syncer.

chrome/test/sync/engine/mock_connection_manager.cc

 // Copyright (c) 2009 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.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
 #include "chrome/test/sync/engine/mock_connection_manager.h"
 
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
@@ skipping 26 matching lines @@
       conflict_all_commits_(false),
       conflict_n_commits_(0),
       next_new_id_(10000),
       store_birthday_("Store BDay!"),
       store_birthday_sent_(false),
       client_stuck_(false),
       commit_time_rename_prepended_string_(""),
       fail_next_postbuffer_(false),
       directory_manager_(dirmgr),
       directory_name_(name),
-      mid_commit_callback_(NULL),
       mid_commit_observer_(NULL),
       throttling_(false),
       fail_with_auth_invalid_(false),
       fail_non_periodic_get_updates_(false),
       client_command_(NULL),
       next_position_in_parent_(2),
       use_legacy_bookmarks_protocol_(false),
       num_get_updates_requests_(0) {
     server_reachable_ = true;
 };
 
 MockConnectionManager::~MockConnectionManager() {
-  for (size_t i = 0; i < commit_messages_.size(); i++)
-    delete commit_messages_[i];
-  delete mid_commit_callback_;
 }
 
 void MockConnectionManager::SetCommitTimeRename(string prepend) {
   commit_time_rename_prepended_string_ = prepend;
 }
 
 void MockConnectionManager::SetMidCommitCallback(Closure* callback) {
-  mid_commit_callback_ = callback;
+  mid_commit_callback_.reset(callback);
 }
 
 void MockConnectionManager::SetMidCommitObserver(
     MockConnectionManager::MidCommitObserver* observer) {
     mid_commit_observer_ = observer;
 }
 
 bool MockConnectionManager::PostBufferToPath(const PostBufferParams* params,
     const string& path,
     const string& auth_token,
@@ skipping 60 matching lines @@
     if (throttling_) {
       response.set_error_code(ClientToServerResponse::THROTTLED);
       throttling_ = false;
     }
 
     if (fail_with_auth_invalid_)
       response.set_error_code(ClientToServerResponse::AUTH_INVALID);
   }
 
   response.SerializeToString(params->buffer_out);
-  if (mid_commit_callback_) {
+  if (post.message_contents() == ClientToServerMessage::COMMIT &&
+      mid_commit_callback_.get()) {
     mid_commit_callback_->Run();
   }
   if (mid_commit_observer_) {
     mid_commit_observer_->Observe();
   }
 
   return result;
 }
 
 bool MockConnectionManager::IsServerReachable() {
@@ skipping 81 matching lines @@
   return AddUpdateFull(id, parent_id, name, version, sync_ts, true);
 }
 
 SyncEntity* MockConnectionManager::AddUpdateBookmark(string id,
                                                      string parent_id,
                                                      string name, int64 version,
                                                      int64 sync_ts) {
   return AddUpdateFull(id, parent_id, name, version, sync_ts, false);
 }
 
+SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
+  EXPECT_EQ(1, last_sent_commit().entries_size());
+  EXPECT_EQ(1, last_commit_response().entryresponse_size());
+  EXPECT_EQ(CommitResponse::SUCCESS,
+      last_commit_response().entryresponse(0).response_type());
+
+  if (last_sent_commit().entries(0).deleted()) {
+    AddUpdateTombstone(syncable::Id::CreateFromServerId(
+        last_sent_commit().entries(0).id_string()));
+  } else {
+    SyncEntity* ent = updates_.add_entries();
+    ent->CopyFrom(last_sent_commit().entries(0));
+    ent->clear_insert_after_item_id();
+    ent->clear_old_parent_id();
+    ent->set_position_in_parent(
+        last_commit_response().entryresponse(0).position_in_parent());
+    ent->set_version(
+        last_commit_response().entryresponse(0).version());
+    ent->set_id_string(
+        last_commit_response().entryresponse(0).id_string());
+    // Tests don't currently care about the following:
+    // originator_cache_guid, originator_client_item_id, parent_id_string,
+    // name, non_unique_name.
+  }
+  return GetMutableLastUpdate();
+}
+
+void MockConnectionManager::AddUpdateTombstone(const syncable::Id& id) {
+  // Tombstones have only the ID set and dummy values for the required fields.
+  SyncEntity* ent = updates_.add_entries();
+  ent->set_id_string(id.GetServerId());
+  ent->set_version(0);
+  ent->set_name("");
+  ent->set_deleted(true);
+}
+
 void MockConnectionManager::SetLastUpdateDeleted() {
-  GetMutableLastUpdate()->set_deleted(true);
+  // Tombstones have only the ID set.  Wipe anything else.
+  string id_string = GetMutableLastUpdate()->id_string();
+  updates_.mutable_entries()->RemoveLast();
+  AddUpdateTombstone(syncable::Id::CreateFromServerId(id_string));
 }
 
 void MockConnectionManager::SetLastUpdateOriginatorFields(
     const string& client_id,
     const string& entry_id) {
   GetMutableLastUpdate()->set_originator_cache_guid(client_id);
   GetMutableLastUpdate()->set_originator_client_item_id(entry_id);
 }
 
 void MockConnectionManager::SetLastUpdateServerTag(const string& tag) {
@@ skipping 96 matching lines @@
   return conflict;
 }
 
 void MockConnectionManager::ProcessCommit(ClientToServerMessage* csm,
     ClientToServerResponse* response_buffer) {
   CHECK(csm->has_commit());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::COMMIT);
   map <string, string> changed_ids;
   const CommitMessage& commit_message = csm->commit();
   CommitResponse* commit_response = response_buffer->mutable_commit();
-  commit_messages_.push_back(new CommitMessage);
-  commit_messages_.back()->CopyFrom(commit_message);
+  commit_messages_->push_back(new CommitMessage);
+  commit_messages_->back()->CopyFrom(commit_message);
   map<string, CommitResponse_EntryResponse*> response_map;
   for (int i = 0; i < commit_message.entries_size() ; i++) {
     const sync_pb::SyncEntity& entry = commit_message.entries(i);
     CHECK(entry.has_id_string());
     string id = entry.id_string();
     ASSERT_LT(entry.name().length(), 256ul) << " name probably too long. True "
         "server name checking not implemented";
     if (entry.version() == 0) {
       // Relies on our new item string id format. (string representation of a
       // negative number).
@@ skipping 21 matching lines @@
       er->set_parent_id_string(parent_id);
     }
     if (entry.has_version() && 0 != entry.version()) {
       er->set_id_string(id);  // Allows verification.
     } else {
       string new_id = StringPrintf("mock_server:%d", next_new_id_++);
       changed_ids[id] = new_id;
       er->set_id_string(new_id);
     }
   }
+  commit_responses_->push_back(new CommitResponse(*commit_response));
 }
 
 SyncEntity* MockConnectionManager::AddUpdateDirectory(
     syncable::Id id, syncable::Id parent_id, string name, int64 version,
     int64 sync_ts) {
   return AddUpdateDirectory(id.GetServerId(), parent_id.GetServerId(),
                             name, version, sync_ts);
 }
 
 SyncEntity* MockConnectionManager::AddUpdateBookmark(
     syncable::Id id, syncable::Id parent_id, string name, int64 version,
     int64 sync_ts) {
   return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(),
                            name, version, sync_ts);
 }
 
 SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
-  DCHECK(updates_.entries_size() > 0);
+  EXPECT_TRUE(updates_.entries_size() > 0);
   return updates_.mutable_entries()->Mutable(updates_.entries_size() - 1);
 }
 
 const CommitMessage& MockConnectionManager::last_sent_commit() const {
-  DCHECK(!commit_messages_.empty());
-  return *commit_messages_.back();
+  EXPECT_TRUE(!commit_messages_.empty());
+  return *commit_messages_->back();
+}
+
+const CommitResponse& MockConnectionManager::last_commit_response() const {
+  EXPECT_TRUE(!commit_responses_.empty());
+  return *commit_responses_->back();
 }
 
 void MockConnectionManager::ThrottleNextRequest(
     ResponseCodeOverrideRequestor* visitor) {
   AutoLock lock(response_code_override_lock_);
   throttling_ = true;
   if (visitor)
     visitor->OnOverrideComplete();
 }
 
@@ skipping 36 matching lines @@
 
 void MockConnectionManager::SetServerNotReachable() {
   server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
   server_reachable_ = false;
   browser_sync::ServerConnectionEvent event = {
     browser_sync::ServerConnectionEvent::STATUS_CHANGED,
     server_status_,
     server_reachable_ };
   channel_->NotifyListeners(event);
 }