[Sync] Move //sync to //components/sync.

components/sync/base/model_type.h

 // 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.
 
 // Enumerate the various item subtypes that are supported by sync.
 // Each sync object is expected to have an immutable object type.
 // An object's type is inferred from the type of data it holds.
 
-#ifndef SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_H_
-#define SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_H_
+#ifndef COMPONENTS_SYNC_BASE_MODEL_TYPE_H_
+#define COMPONENTS_SYNC_BASE_MODEL_TYPE_H_
 
 #include <map>
 #include <memory>
 #include <ostream>
 #include <set>
 #include <string>
 
 #include "base/logging.h"
-#include "sync/base/sync_export.h"
-#include "sync/internal_api/public/base/enum_set.h"
+#include "components/sync/base/enum_set.h"
+#include "components/sync/base/sync_export.h"
 
 namespace base {
 class ListValue;
 class StringValue;
 class Value;
 }
 
 namespace sync_pb {
 class EntitySpecifics;
 class SyncEntity;
 }
 
 namespace syncer {
 
 // TODO(akalin): Move the non-exported functions in this file to a
 // private header.
 
 // A Java counterpart will be generated for this enum.
-// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.sync
+// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.components.sync
 
 // |kModelTypeInfoMap| struct entries are in the same order as their definition
 // in ModelType enum. Don't forget to update the |kModelTypeInfoMap| struct in
 // model_type.cc when you make changes in ModelType enum.
 enum ModelType {
   // Object type unknown.  Objects may transition through
   // the unknown state during their initial creation, before
   // their properties are set.  After deletion, object types
   // are generally preserved.
   UNSPECIFIED,
@@ skipping 109 matching lines @@
   // sync preferences UI, be sure to update the list in
   // components/sync_driver/user_selectable_sync_type.h so that the UMA
   // histograms for sync include your new type.  In this case, be sure to also
   // update the UserSelectableTypes() definition in
   // sync/syncable/model_type.cc.
   MODEL_TYPE_COUNT,
 };
 
 typedef EnumSet<ModelType, FIRST_REAL_MODEL_TYPE, LAST_REAL_MODEL_TYPE>
     ModelTypeSet;
-typedef EnumSet<ModelType, UNSPECIFIED, LAST_REAL_MODEL_TYPE>
-    FullModelTypeSet;
+typedef EnumSet<ModelType, UNSPECIFIED, LAST_REAL_MODEL_TYPE> FullModelTypeSet;
 typedef std::map<syncer::ModelType, const char*> ModelTypeNameMap;
 
 inline ModelType ModelTypeFromInt(int i) {
   DCHECK_GE(i, 0);
   DCHECK_LT(i, MODEL_TYPE_COUNT);
   return static_cast<ModelType>(i);
 }
 
 // Used by tests outside of sync/.
 SYNC_EXPORT void AddDefaultFieldValue(ModelType datatype,
                                       sync_pb::EntitySpecifics* specifics);
 
 // Extract the model type of a SyncEntity protocol buffer.  ModelType is a
 // local concept: the enum is not in the protocol.  The SyncEntity's ModelType
 // is inferred from the presence of particular datatype field in the
 // entity specifics.
 SYNC_EXPORT ModelType GetModelType(const sync_pb::SyncEntity& sync_entity);
 
 // Extract the model type from an EntitySpecifics field.  Note that there
 // are some ModelTypes (like TOP_LEVEL_FOLDER) that can't be inferred this way;
 // prefer using GetModelType where possible.
-SYNC_EXPORT ModelType GetModelTypeFromSpecifics(
-    const sync_pb::EntitySpecifics& specifics);
+SYNC_EXPORT ModelType
+GetModelTypeFromSpecifics(const sync_pb::EntitySpecifics& specifics);
 
 // Protocol types are those types that have actual protocol buffer
 // representations. This distinguishes them from Proxy types, which have no
 // protocol representation and are never sent to the server.
 SYNC_EXPORT ModelTypeSet ProtocolTypes();
 
 // These are the normal user-controlled types. This is to distinguish from
 // ControlTypes which are always enabled.  Note that some of these share a
 // preference flag, so not all of them are individually user-selectable.
 SYNC_EXPORT ModelTypeSet UserTypes();
@@ skipping 57 matching lines @@
 //     if (!IsRealDataType(model_type)) {
 //       DLOG(WARNING) << "Unknown field number " << field_number;
 //       continue;
 //     }
 //     model_types.Put(model_type);
 //   }
 SYNC_EXPORT ModelType GetModelTypeFromSpecificsFieldNumber(int field_number);
 
 // Return the field number of the EntitySpecifics field associated with
 // a model type.
-SYNC_EXPORT int GetSpecificsFieldNumberFromModelType(
-    ModelType model_type);
+SYNC_EXPORT int GetSpecificsFieldNumberFromModelType(ModelType model_type);
 
 FullModelTypeSet ToFullModelTypeSet(ModelTypeSet in);
 
 // TODO(sync): The functions below badly need some cleanup.
 
 // Returns a pointer to a string with application lifetime that represents
 // the name of |model_type|.
 SYNC_EXPORT const char* ModelTypeToString(ModelType model_type);
 
 // Some histograms take an integer parameter that represents a model type.
 // The mapping from ModelType to integer is defined here.  It should match
 // the mapping from integer to labels defined in histograms.xml.
 SYNC_EXPORT int ModelTypeToHistogramInt(ModelType model_type);
 
 // Handles all model types, and not just real ones.
 //
 // Caller takes ownership of returned value.
 SYNC_EXPORT base::StringValue* ModelTypeToValue(ModelType model_type);
 
 // Converts a Value into a ModelType - complement to ModelTypeToValue().
 SYNC_EXPORT ModelType ModelTypeFromValue(const base::Value& value);
 
 // Returns the ModelType corresponding to the name |model_type_string|.
-SYNC_EXPORT ModelType ModelTypeFromString(
-    const std::string& model_type_string);
+SYNC_EXPORT ModelType ModelTypeFromString(const std::string& model_type_string);
 
 // Returns the comma-separated string representation of |model_types|.
 SYNC_EXPORT std::string ModelTypeSetToString(ModelTypeSet model_types);
 
 // Necessary for compatibility with EXPECT_EQ and the like.
 SYNC_EXPORT std::ostream& operator<<(std::ostream& out,
                                      ModelTypeSet model_type_set);
 
 // Returns the set of comma-separated model types from |model_type_string|.
-SYNC_EXPORT ModelTypeSet ModelTypeSetFromString(
-    const std::string& model_type_string);
+SYNC_EXPORT ModelTypeSet
+ModelTypeSetFromString(const std::string& model_type_string);
 
 SYNC_EXPORT std::unique_ptr<base::ListValue> ModelTypeSetToValue(
     ModelTypeSet model_types);
 
 SYNC_EXPORT ModelTypeSet ModelTypeSetFromValue(const base::ListValue& value);
 
 // Returns a string corresponding to the syncable tag for this datatype.
 SYNC_EXPORT std::string ModelTypeToRootTag(ModelType type);
 
 // Returns root_tag for |model_type| in ModelTypeInfo.
@@ skipping 37 matching lines @@
 SYNC_EXPORT bool IsTypeWithClientGeneratedRoot(ModelType model_type);
 
 // Returns true if |model_type| supports parent-child hierarchy or entries.
 SYNC_EXPORT bool TypeSupportsHierarchy(ModelType model_type);
 
 // Returns true if |model_type| supports ordering of sibling entries.
 SYNC_EXPORT bool TypeSupportsOrdering(ModelType model_type);
 
 }  // namespace syncer
 
-#endif  // SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_H_
+#endif  // COMPONENTS_SYNC_BASE_MODEL_TYPE_H_