Enable Null Syncable ID which is different than Root ID.

sync/engine/commit_util.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/commit_util.h"
 
 #include <limits>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 132 matching lines @@
 
   if (meta_entry.ShouldMaintainHierarchy()) {
     sync_entry->set_parent_id_string(SyncableIdToProto(new_parent_id));
   }
 
   // If our parent has changed, send up the old one so the server
   // can correctly deal with multiple parents.
   // TODO(nick): With the server keeping track of the primary sync parent,
   // it should not be necessary to provide the old_parent_id: the version
   // number should suffice.
-  if (new_parent_id != meta_entry.GetServerParentId() &&
+  Id server_parent_id = meta_entry.GetServerParentId();
+  if (new_parent_id != server_parent_id && !server_parent_id.IsNull() &&

[pavely, 2014/12/22 21:38:09]

Could you give examples when server_parent_id will be empty? It seems like there
is change of behavior that might affect server.

[stanisc, 2014/12/22 21:56:01]

Currently parent IDs are never nulls (empty) so there shouldn't be any change in
the behavior, at least not until the next change that will really introduce
empty parent IDs.
I made this change in anticipation of the future change and to avoid changing a
lot of tests that don't bother setting parent IDs explicitly. With the previous
implementation unset parent IDs would all be root IDs (with "r" as their
content). Now that uninitialized IDs end up being empty strings
SyncableIdToProto fails to process an empty string based ID. 
I had two choices. Either adding an extra check here or modify SyncableIdToProto
to handle a null ID the same way it handled a root ID.

[pavely, 2014/12/22 22:00:48]

sgtm

       0 != meta_entry.GetBaseVersion() &&
       syncable::CHANGES_VERSION != meta_entry.GetBaseVersion()) {
-    sync_entry->set_old_parent_id(
-        SyncableIdToProto(meta_entry.GetServerParentId()));
+    sync_entry->set_old_parent_id(SyncableIdToProto(server_parent_id));
   }
 
   int64 version = meta_entry.GetBaseVersion();
   if (syncable::CHANGES_VERSION == version || 0 == version) {
     // Undeletions are only supported for items that have a client tag.
     DCHECK(!id.ServerKnows() ||
            !meta_entry.GetUniqueClientTag().empty())
         << meta_entry;
 
     // Version 0 means to create or undelete an object.
     sync_entry->set_version(0);
   } else {
     DCHECK(id.ServerKnows()) << meta_entry;
     sync_entry->set_version(meta_entry.GetBaseVersion());
   }
   sync_entry->set_ctime(TimeToProtoTime(meta_entry.GetCtime()));
   sync_entry->set_mtime(TimeToProtoTime(meta_entry.GetMtime()));
 
   SetAttachmentIds(meta_entry, sync_entry);
 
   // Handle bookmarks separately.
   if (meta_entry.GetSpecifics().has_bookmark()) {
     if (meta_entry.GetIsDel()) {
       sync_entry->set_deleted(true);
     } else {
       // Both insert_after_item_id and position_in_parent fields are set only
       // for legacy reasons.  See comments in sync.proto for more information.
       const Id& prev_id = meta_entry.GetPredecessorId();
       string prev_id_string =
-          prev_id.IsRoot() ? string() : prev_id.GetServerId();
+          prev_id.IsNull() ? string() : prev_id.GetServerId();
       sync_entry->set_insert_after_item_id(prev_id_string);
       sync_entry->set_position_in_parent(
           meta_entry.GetUniquePosition().ToInt64());
       meta_entry.GetUniquePosition().ToProto(
           sync_entry->mutable_unique_position());
     }
     // Always send specifics for bookmarks.
     SetEntrySpecifics(meta_entry, sync_entry);
     return;
   }
@@ skipping 264 matching lines @@
   }
 
   ProcessSuccessfulCommitResponse(commit_request_entry, server_entry,
       local_entry.GetId(), &local_entry, syncing_was_set, deleted_folders);
   return response;
 }
 
 }  // namespace commit_util
 
 }  // namespace syncer