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

sync/syncable/parent_child_index.h

Index: sync/syncable/parent_child_index.h
diff --git a/sync/syncable/parent_child_index.h b/sync/syncable/parent_child_index.h
index 84c0771403e566642e6065962f463bb0d9cde16a..6689812da803fad2dbf6faf86df3429b8fcbb61a 100644
--- a/sync/syncable/parent_child_index.h
+++ b/sync/syncable/parent_child_index.h
@@ -60,14 +60,32 @@ class SYNC_EXPORT_PRIVATE ParentChildIndex {
 
  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;
@@ -78,6 +96,10 @@ class SYNC_EXPORT_PRIVATE ParentChildIndex {
 
   // 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);
 };