Sync: ParentChildIndex fix for out of order deletion of entries by PurgeEntriesWithTypeIn.

sync/syncable/parent_child_index.cc

 // Copyright (c) 2012 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/syncable/parent_child_index.h"
 
 #include "base/stl_util.h"
 
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/syncable_id.h"
@@ skipping 67 matching lines @@
   }
 
   return children->insert(entry).second;
 }
 
 // Like the other containers used to help support the syncable::Directory, this
 // one does not own any EntryKernels.  This function removes references to the
 // given EntryKernel but does not delete it.
 void ParentChildIndex::Remove(EntryKernel* e) {
   const Id& parent_id = GetParentId(e);
-  // Clear type root ID when removing a type root entry.
-  if (parent_id.IsRoot()) {
-    ModelType model_type = GetModelType(e);
-    // TODO(stanisc): the check is needed to work around some tests.
-    // See TODO above.
-    if (model_type_root_ids_[model_type] == e->ref(ID)) {
-      model_type_root_ids_[model_type] = Id();
-    }
-  }
 
   ParentChildrenMap::iterator parent = parent_children_map_.find(parent_id);
   DCHECK(parent != parent_children_map_.end());
 
   OrderedChildSet* children = parent->second;
   OrderedChildSet::iterator j = children->find(e);
   DCHECK(j != children->end());
 
   children->erase(j);
   if (children->empty()) {
@@ skipping 12 matching lines @@
   const OrderedChildSet* children = parent->second;
   DCHECK(children && !children->empty());
   return children->count(e) > 0;
 }
 
 const OrderedChildSet* ParentChildIndex::GetChildren(const Id& id) const {
   DCHECK(!id.IsNull());
 
   ParentChildrenMap::const_iterator parent = parent_children_map_.find(id);
   if (parent == parent_children_map_.end()) {
-    return NULL;
+    return nullptr;
   }
 
   // A successful lookup implies at least some children exist.
   DCHECK(!parent->second->empty());
   return parent->second;
 }
 
 const OrderedChildSet* ParentChildIndex::GetChildren(EntryKernel* e) const {
   return GetChildren(e->ref(ID));
 }
@@ skipping 23 matching lines @@
 }
 
 const Id& ParentChildIndex::GetModelTypeRootId(ModelType model_type) const {
   // TODO(stanisc): Review whether this approach is reliable enough.
   // Should this method simply enumerate children of root node ("r") instead?
   return model_type_root_ids_[model_type];
 }
 
 }  // namespace syncable
 }  // namespace syncer