Update python sync server to support recursive deletion.

net/tools/testserver/chromiumsync.py

 #!/usr/bin/python2.4
 # Copyright (c) 2010 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.
 
 """An implementation of the server side of the Chromium sync protocol.
 
 The details of the protocol are described mostly by comments in the protocol
 buffer definition at chrome/browser/sync/protocol/sync.proto.
 """
@@ skipping 491 matching lines @@
     # TODO(nick): Implement cycle detection and resolution.
     if not self._CheckParentIdForCommit(entry):
       return None
 
     # At this point, the commit is definitely going to happen.
 
     # Deletion works by storing a limited record for an entry, called a
     # tombstone.  A sync server must track deleted IDs forever, since it does
     # not keep track of client knowledge (there's no deletion ACK event).
     if entry.deleted:
-      # Only the ID, version and deletion state are preserved on a tombstone.
-      # TODO(nick): Does the production server not preserve the type?  Not
-      # doing so means that tombstones cannot be filtered based on
-      # requested_types at GetUpdates time.
-      tombstone = sync_pb2.SyncEntity()
-      tombstone.id_string = entry.id_string
-      tombstone.deleted = True
-      tombstone.name = ''
-      entry = tombstone
+      def MakeTombstone(id_string):
+        """Make a tombstone entry that will replace the entry being deleted.
+
+        Args:
+          id_string: Index of the SyncEntity to be deleted.
+        Returns:
+          A new SyncEntity reflecting the fact that the entry is deleted.
+        """
+        # Only the ID, version and deletion state are preserved on a tombstone.
+        # TODO(nick): Does the production server not preserve the type?  Not
+        # doing so means that tombstones cannot be filtered based on
+        # requested_types at GetUpdates time.
+        tombstone = sync_pb2.SyncEntity()
+        tombstone.id_string = id_string
+        tombstone.deleted = True
+        tombstone.name = ''
+        return tombstone
+
+      def IsChild(child_id):
+        """Check if a SyncEntity is a child of entry, or any of its children.
+
+        Args:
+          child_id: Index of the SyncEntity that is a possible child of entry.
+        Returns:
+          True if it is a child; false otherwise.
+        """
+        if child_id not in self._entries:
+          return False
+        if self._entries[child_id].parent_id_string == entry.id_string:
+          return True
+        return IsChild(self._entries[child_id].parent_id_string)
+
+      # Identify any children entry might have.
+      child_ids = []
+      for possible_child in self._entries.itervalues():
+        if IsChild(possible_child.id_string):
+          child_ids.append(possible_child.id_string)
+
+      # Mark all children that were identified as deleted.
+      for child_id in child_ids:
+        self._SaveEntry(MakeTombstone(child_id))
+
+      # Delete entry itself.
+      entry = MakeTombstone(entry.id_string)
     else:
       # Comments in sync.proto detail how the representation of positional
       # ordering works: the 'insert_after_item_id' field specifies a
       # predecessor during Commit operations, but the 'position_in_parent'
       # field provides an absolute ordering in GetUpdates contexts.  Here
       # we convert from the former to the latter.  Specifically, we'll
       # generate a numeric position placing the item just after the object
       # identified by 'insert_after_item_id', and then clear the
       # 'insert_after_item_id' field so that it's not sent back to the client
       # during later GetUpdates requests.
       if entry.HasField('insert_after_item_id'):
         self._WritePosition(entry, entry.parent_id_string,
                             entry.insert_after_item_id)
       else:
         self._WritePosition(entry, entry.parent_id_string)
 
     # Preserve the originator info, which the client is not required to send
     # when updating.
     base_entry = self._entries.get(entry.id_string)
     if base_entry and not entry.HasField("originator_cache_guid"):
       entry.originator_cache_guid = base_entry.originator_cache_guid
       entry.originator_client_item_id = base_entry.originator_client_item_id
 
     # Commit the change.  This also updates the version number.
     self._SaveEntry(entry)
-    # TODO(nick): Handle recursive deletion.
     return entry
 
 class TestServer(object):
   """An object to handle requests for one (and only one) Chrome Sync account.
 
   TestServer consumes the sync command messages that are the outermost
   layers of the protocol, performs the corresponding actions on its
   SyncDataModel, and constructs an appropropriate response message.
   """
 
@@ skipping 101 matching lines @@
     new_timestamp, entries = self.account.GetChangesFromTimestamp(
         requested_types, update_request.from_timestamp)
 
     # If the client is up to date, we are careful not to set the
     # new_timestamp field.
     if new_timestamp != update_request.from_timestamp:
       update_response.new_timestamp = new_timestamp
       for e in entries:
         reply = update_response.entries.add()
         reply.CopyFrom(e)