Remove dependency on server generated type root folders

sync/engine/syncer_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/engine/syncer_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 166 matching lines @@
 
       // Just a quick sanity check.
       DCHECK(!local_entry.GetId().ServerKnows());
 
       DVLOG(1) << "Reuniting lost commit response IDs. server id: "
                << update_id << " local id: " << local_entry.GetId()
                << " new version: " << new_version;
 
       return local_entry.GetId();
     }
+  } else if (update.has_server_defined_unique_tag() &&
+             !update.server_defined_unique_tag().empty()) {
+    // The client creates type root folders with a local ID on demand when a
+    // progress marker for the given type is initially set.
+    // The server might also attempt to send a type root folder for the same
+    // type (during the transition period until support for root folders is
+    // removed for new client versions).
+    // TODO(stanisc): crbug.com/438313: remove this once the transition to
+    // implicit root folders on the server is done.
+    syncable::Entry local_entry(trans, syncable::GET_BY_SERVER_TAG,
+                                update.server_defined_unique_tag());
+    if (local_entry.good() && !local_entry.GetId().ServerKnows()) {
+      DCHECK(local_entry.GetId() != update_id);
+      return local_entry.GetId();
+    }
   }
+
   // Fallback: target an entry having the server ID, creating one if needed.
   return update_id;
 }
 
 UpdateAttemptResponse AttemptToUpdateEntry(
     syncable::WriteTransaction* const trans,
     syncable::MutableEntry* const entry,
     Cryptographer* cryptographer) {
   CHECK(entry->good());
   if (!entry->GetIsUnappliedUpdate())
     return SUCCESS;  // No work to do.
   syncable::Id id = entry->GetId();
   const sync_pb::EntitySpecifics& specifics = entry->GetServerSpecifics();
+  ModelType type = GetModelTypeFromSpecifics(specifics);
 
   // Only apply updates that we can decrypt. If we can't decrypt the update, it
   // is likely because the passphrase has not arrived yet. Because the
   // passphrase may not arrive within this GetUpdates, we can't just return
   // conflict, else we try to perform normal conflict resolution prematurely or
   // the syncer may get stuck. As such, we return CONFLICT_ENCRYPTION, which is
   // treated as an unresolvable conflict. See the description in syncer_types.h.
   // This prevents any unsynced changes from commiting and postpones conflict
   // resolution until all data can be decrypted.
   if (specifics.has_encrypted() &&
       !cryptographer->CanDecrypt(specifics.encrypted())) {
     // We can't decrypt this node yet.
     DVLOG(1) << "Received an undecryptable "
              << ModelTypeToString(entry->GetServerModelType())
              << " update, returning conflict_encryption.";
     return CONFLICT_ENCRYPTION;
   } else if (specifics.has_password() &&
              entry->GetUniqueServerTag().empty()) {
     // Passwords use their own legacy encryption scheme.
     const sync_pb::PasswordSpecifics& password = specifics.password();
     if (!cryptographer->CanDecrypt(password.encrypted())) {
       DVLOG(1) << "Received an undecryptable password update, returning "
                << "conflict_encryption.";
       return CONFLICT_ENCRYPTION;
     }
   }
 
   if (!entry->GetServerIsDel()) {
     syncable::Id new_parent = entry->GetServerParentId();
-    Entry parent(trans, GET_BY_ID,  new_parent);
-    // A note on non-directory parents:
-    // We catch most unfixable tree invariant errors at update receipt time,
-    // however we deal with this case here because we may receive the child
-    // first then the illegal parent. Instead of dealing with it twice in
-    // different ways we deal with it once here to reduce the amount of code and
-    // potential errors.
-    if (!parent.good() || parent.GetIsDel() || !parent.GetIsDir()) {
-      DVLOG(1) <<  "Entry has bad parent, returning conflict_hierarchy.";
-      return CONFLICT_HIERARCHY;
-    }
-    if (entry->GetParentId() != new_parent) {
-      if (!entry->GetIsDel() && !IsLegalNewParent(trans, id, new_parent)) {
-        DVLOG(1) << "Not updating item " << id
-                 << ", illegal new parent (would cause loop).";
+    if (!new_parent.IsNull()) {
+      // Perform this step only if the parent is specified.
+      // The unset parent means that the implicit type root would be used.
+      Entry parent(trans, GET_BY_ID, new_parent);
+      // A note on non-directory parents:
+      // We catch most unfixable tree invariant errors at update receipt time,
+      // however we deal with this case here because we may receive the child
+      // first then the illegal parent. Instead of dealing with it twice in
+      // different ways we deal with it once here to reduce the amount of code
+      // and potential errors.
+      if (!parent.good() || parent.GetIsDel() || !parent.GetIsDir()) {
+        DVLOG(1) << "Entry has bad parent, returning conflict_hierarchy.";
         return CONFLICT_HIERARCHY;
       }
+      if (entry->GetParentId() != new_parent) {
+        if (!entry->GetIsDel() && !IsLegalNewParent(trans, id, new_parent)) {
+          DVLOG(1) << "Not updating item " << id
+                   << ", illegal new parent (would cause loop).";
+          return CONFLICT_HIERARCHY;
+        }
+      }
+    } else {
+      // new_parent is unset.
+      DCHECK(!IsTypeWithServerGeneratedRoot(type));
     }
   } else if (entry->GetIsDir()) {
     Directory::Metahandles handles;
     trans->directory()->GetChildHandlesById(trans, id, &handles);
     if (!handles.empty()) {
       // If we have still-existing children, then we need to deal with
       // them before we can process this change.
       DVLOG(1) << "Not deleting directory; it's not empty " << *entry;
       return CONFLICT_HIERARCHY;
     }
@@ skipping 388 matching lines @@
   if (update.version() < target->GetServerVersion()) {
     LOG(WARNING) << "Update older than current server version for "
                  << *target << " Update:"
                  << SyncerProtoUtil::SyncEntityDebugString(update);
     return VERIFY_SUCCESS;  // Expected in new sync protocol.
   }
   return VERIFY_UNDECIDED;
 }
 
 }  // namespace syncer