Sync: Support nodes with implicit permanent folders: Node Browser and out-of-order loading from DB

sync/syncable/parent_child_index.h

 // 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.
 
 #ifndef SYNC_SYNCABLE_PARENT_CHILD_INDEX
 #define SYNC_SYNCABLE_PARENT_CHILD_INDEX
 
 #include <map>
 #include <set>
 
@@ skipping 42 matching lines @@
 
   // Returns all children of the entry.  Returns NULL if the node has no
   // children.
   const OrderedChildSet* GetChildren(EntryKernel* e) const;
 
   // Returns all siblings of the entry.
   const OrderedChildSet* GetSiblings(EntryKernel* e) const;
 
  private:
   friend class ParentChildIndexTest;
-  typedef std::map<Id, OrderedChildSet*> ParentChildrenMap;
 
-  // Determines entry's model type.
-  static ModelType GetModelType(EntryKernel* e);
+  struct ChildSetEntry {

[Nicolas Zea, 2015/07/09 20:36:34]

Comment about what this does? In particular would be good to explain "owned",
and how it relates to types with or without parent ids?

On a related note, it's not clear to me why "owned" is needed. Couldn't all
OrderedChildSets be owned by the parent_children_map_? (and the
type_root_child_sets could simply be pointers)

[stanisc, 2015/07/09 21:45:17]

The main problem is that entries might be inserted before their parent ID is
known. I considered transferring ownership to parent_children_map_ for such
entries but though that the logic would end up being more complex because the
per-model-type array would now end up conditionally owning some collections. Let
me consider this approach one more time. 

[stanisc, 2015/07/09 23:59:27]

Done. Reimplemented this without ChildSetEntry.

+    ChildSetEntry(OrderedChildSet* child_set, bool owned)
+        : child_set_(child_set), owned_(owned) {}
 
-  // Returns parent ID for the entry which is either its PARENT_ID value
-  // or derived from its model type.
-  const Id& GetParentId(EntryKernel* e) const;
+    OrderedChildSet* const& child_set() const { return child_set_; }
+    bool owned() const { return owned_; }
+
+    static const ChildSetEntry& Empty();
+
+   private:
+    OrderedChildSet* child_set_;
+    bool owned_;
+  };
+
+  typedef std::map<Id, ChildSetEntry> ParentChildrenMap;
+
+  static bool ShouldUseParentId(const Id& parent_id, ModelType model_type);
+
+  // Returns OrderedChildSet that should contain the specified entry
+  // based on the entry's Parent ID or model type.
+  const OrderedChildSet* GetChildSet(EntryKernel* e) const;
+
+  // Inserts a new child set in the map. The ownership depends on
+  // |child_set_entry.owned()| flag.
+  void InsertChildSet(const Id& id, const ChildSetEntry& child_set_entry);
 
   // Returns previously cached model type root ID for the given |model_type|.
   const Id& GetModelTypeRootId(ModelType model_type) const;
 
   // A map of parent IDs to children.
   // Parents with no children are not included in this map.
   ParentChildrenMap parent_children_map_;
 
   // This array tracks model type roots IDs.
   Id model_type_root_ids_[MODEL_TYPE_COUNT];
+  // This array contains pre-defined child sets for

[Nicolas Zea, 2015/07/09 20:36:34]

nit: newline above

[stanisc, 2015/07/09 23:59:27]

Done.

+  // non-hierarchical types (types with flat hierarchy) that support entries
+  // with implicit parent.
+  OrderedChildSet type_root_child_sets_[MODEL_TYPE_COUNT];
 
   DISALLOW_COPY_AND_ASSIGN(ParentChildIndex);
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif  // SYNC_SYNCABLE_PARENT_CHILD_INDEX