Sync: Support nodes with implicit permanent folders: Node Browser and out-of-order loading from DB

sync/syncable/entry_kernel.cc

 // Copyright (c) 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/entry_kernel.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "sync/protocol/proto_value_conversions.h"
 #include "sync/syncable/syncable_enum_conversions.h"
 #include "sync/util/cryptographer.h"
@@ skipping 34 matching lines @@
   // bound to a particular model type.
   if (!ref(UNIQUE_SERVER_TAG).empty() && ref(SERVER_IS_DIR))
     return TOP_LEVEL_FOLDER;
 
   return UNSPECIFIED;
 }
 
 bool EntryKernel::ShouldMaintainPosition() const {
   // We maintain positions for all bookmarks, except those that are
   // server-created top-level folders.
-  return (GetModelTypeFromSpecifics(ref(SPECIFICS)) == syncer::BOOKMARKS)
-      && !(!ref(UNIQUE_SERVER_TAG).empty() && ref(IS_DIR));
+  return TypeSupportsOrdering(GetModelTypeFromSpecifics(ref(SPECIFICS))) &&
+         !(!ref(UNIQUE_SERVER_TAG).empty() && ref(IS_DIR));
 }
 
 bool EntryKernel::ShouldMaintainHierarchy() const {
   // We maintain hierarchy for bookmarks and top-level folders,
   // but no other types.  Note that the Nigori node consists of a single
   // top-level folder, so it's included in this set.
-  return (GetModelTypeFromSpecifics(ref(SPECIFICS)) == syncer::BOOKMARKS)
-      || (!ref(UNIQUE_SERVER_TAG).empty());
+  return TypeSupportsHierarchy(GetModelTypeFromSpecifics(ref(SPECIFICS))) ||
+         (!ref(UNIQUE_SERVER_TAG).empty());
 }
 
 namespace {
 
 // Utility function to loop through a set of enum values and add the
 // field keys/values in the kernel to the given dictionary.
 //
 // V should be convertible to Value.
 template <class T, class U, class V>
 void SetFieldValues(const EntryKernel& kernel,
@@ skipping 66 matching lines @@
     const sync_pb::AttachmentMetadata& a) {
   return new base::StringValue(a.SerializeAsString());
 }
 
 }  // namespace
 
 base::DictionaryValue* EntryKernel::ToValue(
     Cryptographer* cryptographer) const {
   base::DictionaryValue* kernel_info = new base::DictionaryValue();
   kernel_info->SetBoolean("isDirty", is_dirty());
-  kernel_info->Set("serverModelType", ModelTypeToValue(GetServerModelType()));
+  ModelType dataType = GetServerModelType();
+  if (!IsRealDataType(dataType))
+    dataType = GetModelType();
+  kernel_info->Set("modelType", ModelTypeToValue(dataType));
 
   // Int64 fields.
   SetFieldValues(*this, kernel_info,
                  &GetMetahandleFieldString, &Int64ToValue,
                  INT64_FIELDS_BEGIN, META_HANDLE);
   SetFieldValues(*this, kernel_info,
                  &GetBaseVersionString, &Int64ToValue,
                  META_HANDLE + 1, BASE_VERSION);
   SetFieldValues(*this, kernel_info,
                  &GetInt64FieldString, &Int64ToValue,
@@ skipping 66 matching lines @@
 base::DictionaryValue* EntryKernelMutationToValue(
     const EntryKernelMutation& mutation) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->Set("original", mutation.original.ToValue(NULL));
   dict->Set("mutated", mutation.mutated.ToValue(NULL));
   return dict;
 }
 
 }  // namespace syncer
 }  // namespace syncable