Remove dependency on server generated type root folders

sync/engine/directory_update_handler.cc

 // Copyright 2014 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/directory_update_handler.h"
 
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/process_updates_util.h"
 #include "sync/engine/update_applicator.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/syncable/directory.h"
+#include "sync/syncable/model_neutral_mutable_entry.h"
 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
 #include "sync/syncable/syncable_write_transaction.h"
 
 namespace syncer {
 
 using syncable::SYNCER;
 
 DirectoryUpdateHandler::DirectoryUpdateHandler(
     syncable::Directory* dir,
     ModelType type,
@@ skipping 36 matching lines @@
       // TODO(zea): trigger the datatype's UpdateDataTypeContext method.
     } else if (mutated_context.version() < local_context.version()) {
       // A GetUpdates using the old context was in progress when the context was
       // set. Fail this get updates cycle, to force a retry.
       DVLOG(1) << "GU Context conflict detected, forcing GU retry.";
       debug_info_emitter_->EmitUpdateCountersUpdate();
       return DATATYPE_TRIGGERED_RETRY;
     }
   }
 
+  // Auto-create permanent folder for the type if the progress marker
+  // changes from empty to non-empty.
+  if (!IsTypeWithServerGeneratedRoot(type_) &&
+      dir_->HasEmptyDownloadProgress(type_) &&
+      IsValidProgressMarker(progress_marker)) {
+    CreateTypeRoot(&trans);
+  }
+
   UpdateSyncEntities(&trans, applicable_updates, status);
 
   if (IsValidProgressMarker(progress_marker)) {
     ExpireEntriesIfNeeded(&trans, progress_marker);
     UpdateProgressMarker(progress_marker);
   }
+
   debug_info_emitter_->EmitUpdateCountersUpdate();
   return SYNCER_OK;
 }
 
+void DirectoryUpdateHandler::CreateTypeRoot(
+    syncable::ModelNeutralWriteTransaction* trans) {
+  syncable::ModelNeutralMutableEntry entry(
+      trans, syncable::CREATE_NEW_TYPE_ROOT, type_);
+  if (!entry.good()) {
+    // This will fail only if matching entry already exists, for example
+    // if the type gets disabled and its progress marker gets cleared,
+    // then the type gets re-enabled again.
+    DVLOG(1) << "Type root folder " << ModelTypeToRootTag(type_)
+             << " already exists.";
+    return;
+  }
+
+  entry.PutServerIsDir(true);
+  entry.PutUniqueServerTag(ModelTypeToRootTag(type_));
+}
+
 void DirectoryUpdateHandler::ApplyUpdates(sessions::StatusController* status) {
   if (!IsApplyUpdatesRequired()) {
     return;
   }
 
   // This will invoke handlers that belong to the model and its thread, so we
   // switch to the appropriate thread before we start this work.
   WorkCallback c = base::Bind(
       &DirectoryUpdateHandler::ApplyUpdatesImpl,
       // We wait until the callback is executed.  We can safely use Unretained.
@@ skipping 110 matching lines @@
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
   UpdateCounters* counters = debug_info_emitter_->GetMutableUpdateCounters();
   counters->num_updates_received += applicable_updates.size();
   ProcessDownloadedUpdates(dir_, trans, type_,
                            applicable_updates, status, counters);
 }
 
 bool DirectoryUpdateHandler::IsValidProgressMarker(
     const sync_pb::DataTypeProgressMarker& progress_marker) const {
+  if (progress_marker.token().empty()) {
+    return false;
+  }
   int field_number = progress_marker.data_type_id();
   ModelType model_type = GetModelTypeFromSpecificsFieldNumber(field_number);
   if (!IsRealDataType(model_type) || type_ != model_type) {
     NOTREACHED()
         << "Update handler of type " << ModelTypeToString(type_)
         << " asked to process progress marker with invalid type "
         << field_number;
     return false;
   }
   return true;
@@ skipping 34 matching lines @@
               new_gc_directive.version_watermark())) {
     ExpireEntriesByVersion(dir_, trans, type_,
                            new_gc_directive.version_watermark());
   }
 
   cached_gc_directive_.reset(
       new sync_pb::GarbageCollectionDirective(new_gc_directive));
 }
 
 }  // namespace syncer