Revert of [Sync] Move //components/sync to the syncer namespace. (patchset #5 id:40001 of https://co

components/sync/syncable/parent_child_index.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 "components/sync/syncable/parent_child_index.h"
 
-#include <utility>
-
 #include "base/stl_util.h"
 #include "components/sync/syncable/entry_kernel.h"
 
 namespace syncer {
 namespace syncable {
 
 bool ChildComparator::operator()(const EntryKernel* a,
                                  const EntryKernel* b) const {
   const UniquePosition& a_pos = a->ref(UNIQUE_POSITION);
   const UniquePosition& b_pos = b->ref(UNIQUE_POSITION);
@@ skipping 56 matching lines @@
     siblings = GetOrCreateModelTypeChildSet(model_type);
   }
 
   // If this is one of type root folder for a non-hierarchical type, associate
   // its ID with the model type and the type's pre-defined child set with the
   // type root ID.
   // TODO(stanisc): crbug/438313: Just TypeSupportsHierarchy condition should
   // theoretically be sufficient but in practice many tests don't properly
   // initialize entries so TypeSupportsHierarchy ends up failing. Consider
   // tweaking TypeSupportsHierarchy and fixing all related test code.
-  if (parent_id.IsRoot() && entry->ref(IS_DIR) && IsRealDataType(model_type) &&
+  if (parent_id.IsRoot() && entry->ref(IS_DIR) &&
+      syncer::IsRealDataType(model_type) &&
       !TypeSupportsHierarchy(model_type)) {
     const Id& type_root_id = entry->ref(ID);
 
     // If the entry exists in the map it must already have the same
     // model type specific child set. It's possible another type root exists
     // in parent_children_map_, but that's okay as the new type root will
     // point to the same OrderedChildSet. As such, we just blindly store the
     // new type root ID and associate it to the (possibly existing) child set.
     model_type_root_ids_[model_type] = type_root_id;
     parent_children_map_.insert(
@@ skipping 71 matching lines @@
   return siblings.get();
 }
 
 /* static */
 bool ParentChildIndex::ShouldUseParentId(const Id& parent_id,
                                          ModelType model_type) {
   // For compatibility with legacy unit tests, in addition to hierarchical
   // entries, this returns true any entries directly under root and for entries
   // of UNSPECIFIED model type.
   return parent_id.IsRoot() || TypeSupportsHierarchy(model_type) ||
-         !IsRealDataType(model_type);
+         !syncer::IsRealDataType(model_type);
 }
 
 const OrderedChildSetRef ParentChildIndex::GetChildSet(EntryKernel* e) const {
   ModelType model_type = e->GetModelType();
 
   const Id& parent_id = e->ref(PARENT_ID);
   if (ShouldUseParentId(parent_id, model_type)) {
     // Hierarchical type, lookup child set in the map.
     ParentChildrenMap::const_iterator it = parent_children_map_.find(parent_id);
     if (it == parent_children_map_.end())
@@ skipping 17 matching lines @@
         OrderedChildSetRef(new OrderedChildSet());
   return type_root_child_sets_[model_type];
 }
 
 const Id& ParentChildIndex::GetModelTypeRootId(ModelType model_type) const {
   return model_type_root_ids_[model_type];
 }
 
 }  // namespace syncable
 }  // namespace syncer