Sync: support implicit permanent folders in commits.

sync/engine/get_commit_ids.cc

 // Copyright 2013 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/engine/get_commit_ids.h"
 
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 236 matching lines @@
   void AddPredecessorsThenItem(
       const std::set<int64>& ready_unsynced_set,
       const syncable::Entry& item,
       syncable::Directory::Metahandles* result) const;
 
   bool AddDeletedParents(const std::set<int64>& ready_unsynced_set,
                          const syncable::Entry& item,
                          const syncable::Directory::Metahandles& traversed,
                          syncable::Directory::Metahandles* result) const;
 
+  bool SupportsHierarchy(const syncable::Entry& item) const;
+
   // Returns true if we've collected enough items.
   bool IsFull() const;
 
   // Returns true if the specified handle is already in the traversal.
   bool HaveItem(int64 handle) const;
 
   // Adds the specified handles to the traversal.
   void AppendManyToTraversal(const syncable::Directory::Metahandles& handles);
 
   // Adds the specifed handle to the traversal.
@@ skipping 14 matching lines @@
   : out_(out),
     max_entries_(max_entries),
     trans_(trans) { }
 
 Traversal::~Traversal() {}
 
 bool Traversal::AddUncommittedParentsAndTheirPredecessors(
     const std::set<int64>& ready_unsynced_set,
     const syncable::Entry& item,
     syncable::Directory::Metahandles* result) const {
+  DCHECK(SupportsHierarchy(item));
   syncable::Directory::Metahandles dependencies;
   syncable::Id parent_id = item.GetParentId();
 
   // Climb the tree adding entries leaf -> root.
   while (!parent_id.ServerKnows()) {
     syncable::Entry parent(trans_, syncable::GET_BY_ID, parent_id);
     CHECK(parent.good()) << "Bad user-only parent in item path.";
     int64 handle = parent.GetMetahandle();
     if (HaveItem(handle)) {
       // We've already added this parent (and therefore all of its parents).
@@ skipping 85 matching lines @@
 // (false) if a node along the traversal is in a conflict state.
 //
 // The result list is reversed before it is returned, so the resulting
 // traversal is in top to bottom order.  Also note that this function appends
 // to the result list without clearing it.
 bool Traversal::AddDeletedParents(
     const std::set<int64>& ready_unsynced_set,
     const syncable::Entry& item,
     const syncable::Directory::Metahandles& traversed,
     syncable::Directory::Metahandles* result) const {
+  DCHECK(SupportsHierarchy(item));
   syncable::Directory::Metahandles dependencies;
   syncable::Id parent_id = item.GetParentId();
 
   // Climb the tree adding entries leaf -> root.
   while (!parent_id.IsRoot()) {
     syncable::Entry parent(trans_, syncable::GET_BY_ID, parent_id);
 
     if (!parent.good()) {
       // This is valid because the parent could have gone away a long time ago
       //
@@ skipping 35 matching lines @@
 }
 
 bool Traversal::IsFull() const {
   return out_->size() >= max_entries_;
 }
 
 bool Traversal::HaveItem(int64 handle) const {
   return added_handles_.find(handle) != added_handles_.end();
 }
 
+bool Traversal::SupportsHierarchy(const syncable::Entry& item) const {
+  return !item.GetParentId().IsNull();
+}
+
 void Traversal::AppendManyToTraversal(
     const syncable::Directory::Metahandles& handles) {
   out_->insert(out_->end(), handles.begin(), handles.end());
   added_handles_.insert(handles.begin(), handles.end());
 }
 
 void Traversal::AppendToTraversal(int64 metahandle) {
   out_->push_back(metahandle);
   added_handles_.insert(metahandle);
 }
 
 void Traversal::AddCreatesAndMoves(
     const std::set<int64>& ready_unsynced_set) {
   // Add moves and creates, and prepend their uncommitted parents.
   for (std::set<int64>::const_iterator iter = ready_unsynced_set.begin();
        !IsFull() && iter != ready_unsynced_set.end(); ++iter) {
     int64 metahandle = *iter;
     if (HaveItem(metahandle))
       continue;
 
     syncable::Entry entry(trans_,
                           syncable::GET_BY_HANDLE,
                           metahandle);
     if (!entry.GetIsDel()) {
-      // We only commit an item + its dependencies if it and all its
-      // dependencies are not in conflict.
-      syncable::Directory::Metahandles item_dependencies;
-      if (AddUncommittedParentsAndTheirPredecessors(
-              ready_unsynced_set,
-              entry,
-              &item_dependencies)) {
-        AddPredecessorsThenItem(ready_unsynced_set,
-                                entry,
-                                &item_dependencies);
-        AppendManyToTraversal(item_dependencies);
+      if (SupportsHierarchy(entry)) {
+        // We only commit an item + its dependencies if it and all its
+        // dependencies are not in conflict.
+        syncable::Directory::Metahandles item_dependencies;
+        if (AddUncommittedParentsAndTheirPredecessors(ready_unsynced_set, entry,
+                                                      &item_dependencies)) {
+          AddPredecessorsThenItem(ready_unsynced_set, entry,
+                                  &item_dependencies);
+          AppendManyToTraversal(item_dependencies);
+        }
+      } else {
+        // No hierarchy dependencies, just commit the item itself.
+        AppendToTraversal(metahandle);
       }
     }
   }
 
   // It's possible that we overcommitted while trying to expand dependent
   // items.  If so, truncate the set down to the allowed size.
   if (out_->size() > max_entries_)
     out_->resize(max_entries_);
 }
 
@@ skipping 12 matching lines @@
 
     if (std::find(deletion_list.begin(), deletion_list.end(), metahandle) !=
         deletion_list.end()) {
       continue;
     }
 
     syncable::Entry entry(trans_, syncable::GET_BY_HANDLE,
                           metahandle);
 
     if (entry.GetIsDel()) {
-      syncable::Directory::Metahandles parents;
-      if (AddDeletedParents(
-              ready_unsynced_set, entry, deletion_list, &parents)) {
-        // Append parents and chilren in top to bottom order.
-        deletion_list.insert(deletion_list.end(),
-                             parents.begin(),
-                             parents.end());
+      if (SupportsHierarchy(entry)) {
+        syncable::Directory::Metahandles parents;
+        if (AddDeletedParents(ready_unsynced_set, entry, deletion_list,
+                              &parents)) {
+          // Append parents and chilren in top to bottom order.
+          deletion_list.insert(deletion_list.end(), parents.begin(),
+                               parents.end());
+          deletion_list.push_back(metahandle);
+        }
+      } else {
         deletion_list.push_back(metahandle);
       }
     }
   }
 
   // We've been gathering deletions in top to bottom order.  Now we reverse the
   // order as we prepare the list.
   std::reverse(deletion_list.begin(), deletion_list.end());
   AppendManyToTraversal(deletion_list);
 
@@ skipping 22 matching lines @@
   // Add moves and creates, and prepend their uncommitted parents.
   traversal.AddCreatesAndMoves(ready_unsynced_set);
 
   // Add all deletes.
   traversal.AddDeletes(ready_unsynced_set);
 }
 
 }  // namespace
 
 }  // namespace syncer