Enable Null Syncable ID which is different than Root ID.

sync/syncable/directory.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/syncable/directory.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/base64.h"
@@ skipping 1174 matching lines @@
     if (!e.GetIsDel()) {
       if (!SyncAssert(id != parentid, FROM_HERE,
                       "Id should be different from parent id.",
                       trans))
          return false;
       if (!SyncAssert(!e.GetNonUniqueName().empty(), FROM_HERE,
                       "Non unique name should not be empty.",
                       trans))
         return false;
       int safety_count = handles.size() + 1;
+      // TODO(stanisc): handle items with Null parentid
       while (!parentid.IsRoot()) {
         Entry parent(trans, GET_BY_ID, parentid);
         if (!SyncAssert(parent.good(), FROM_HERE,
                         "Parent entry is not valid.",
                         trans))
           return false;
         if (handles.end() == handles.find(parent.GetMetahandle()))
             break; // Skip further checking if parent was unmodified.
         if (!SyncAssert(parent.GetIsDir(), FROM_HERE,
                         "Parent should be a directory",
@@ skipping 180 matching lines @@
   ScopedKernelLock lock(this);
   ScopedParentChildIndexUpdater updater(lock, e, &kernel_->parent_child_index);
 
   // Note: The ScopedParentChildIndexUpdater will update this set for us as we
   // leave this function.
   const OrderedChildSet* siblings =
       kernel_->parent_child_index.GetChildren(e->ref(PARENT_ID));
 
   if (!siblings) {
     // This parent currently has no other children.
-    DCHECK(predecessor->ref(ID).IsRoot());
+    DCHECK(predecessor == NULL);
     UniquePosition pos = UniquePosition::InitialPosition(suffix);
     e->put(UNIQUE_POSITION, pos);
     return;
   }
 
-  if (predecessor->ref(ID).IsRoot()) {
+  if (predecessor == NULL) {
     // We have at least one sibling, and we're inserting to the left of them.
     UniquePosition successor_pos = (*siblings->begin())->ref(UNIQUE_POSITION);
 
     UniquePosition pos;
     if (!successor_pos.IsValid()) {
       // If all our successors are of non-positionable types, just create an
       // initial position.  We arbitrarily choose to sort invalid positions to
       // the right of the valid positions.
       //
       // We really shouldn't need to support this.  See TODO above.
@@ skipping 111 matching lines @@
   // TODO(maniscalco): Eliminate redundant metadata storage (bug 415203).
   std::set_difference(not_on_server_id_set.begin(),
                       not_on_server_id_set.end(),
                       on_server_id_set.begin(),
                       on_server_id_set.end(),
                       std::inserter(*id_set, id_set->end()));
 }
 
 }  // namespace syncable
 }  // namespace syncer