Remove dependency on server generated type root folders

sync/syncable/syncable_util.cc

 // Copyright 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/syncable_util.h"
 
 #include "base/base64.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sha1.h"
@@ skipping 10 matching lines @@
 int GetUnsyncedEntries(BaseTransaction* trans,
                        std::vector<int64> *handles) {
   trans->directory()->GetUnsyncedMetaHandles(trans, handles);
   DVLOG_IF(1, !handles->empty()) << "Have " << handles->size()
                                  << " unsynced items.";
   return handles->size();
 }
 
 bool IsLegalNewParent(BaseTransaction* trans, const Id& entry_id,
                       const Id& new_parent_id) {
+  DCHECK(!entry_id.IsNull());
   if (entry_id.IsRoot())
     return false;
+  if (new_parent_id.IsNull())
+    return true;

[Nicolas Zea, 2015/01/26 23:21:53]

Should this be false here for bookmarks?

[stanisc, 2015/01/28 07:30:06]

Yes, I agree. I'll see if this check could be done outside based on the
datatype.

[stanisc, 2015/01/29 00:27:37]

Done.

   // we have to ensure that the entry is not an ancestor of the new parent.
   Id ancestor_id = new_parent_id;
   while (!ancestor_id.IsRoot()) {
     if (entry_id == ancestor_id)
       return false;
     Entry new_parent(trans, GET_BY_ID, ancestor_id);
     if (!SyncAssert(new_parent.good(),
                     FROM_HERE,
                     "Invalid new parent",
                     trans))
@@ skipping 16 matching lines @@
                << *entry << "\n\n" << old_entry;
   }
   if (entry->GetIsDir()) {
     // Get all child entries of the old id.
     Directory::Metahandles children;
     trans->directory()->GetChildHandlesById(trans, old_id, &children);
     Directory::Metahandles::iterator i = children.begin();
     while (i != children.end()) {
       ModelNeutralMutableEntry child_entry(trans, GET_BY_HANDLE, *i++);
       CHECK(child_entry.good());
-      // Use the unchecked setter here to avoid touching the child's
-      // UNIQUE_POSITION field.  In this case, UNIQUE_POSITION among the
-      // children will be valid after the loop, since we update all the children
-      // at once.
-      child_entry.PutParentIdPropertyOnly(new_id);
+      // Change the parent ID of the entry unless it was unset (implicit)
+      if (!child_entry.GetParentId().IsNull()) {
+        // Use the unchecked setter here to avoid touching the child's
+        // UNIQUE_POSITION field.  In this case, UNIQUE_POSITION among the
+        // children will be valid after the loop, since we update all the
+        // children at once.
+        child_entry.PutParentIdPropertyOnly(new_id);
+      }
     }
   }
 }
 
 // Function to handle runtime failures on syncable code. Rather than crashing,
 // if the |condition| is false the following will happen:
 // 1. Sets unrecoverable error on transaction.
 // 2. Returns false.
 bool SyncAssert(bool condition,
                 const tracked_objects::Location& location,
@@ skipping 23 matching lines @@
 
 std::string GenerateSyncableBookmarkHash(
     const std::string& originator_cache_guid,
     const std::string& originator_client_item_id) {
   return syncable::GenerateSyncableHash(
       BOOKMARKS, originator_cache_guid + originator_client_item_id);
 }
 
 }  // namespace syncable
 }  // namespace syncer