Fixed unneccesary label changes and duplication.

I241cfe4a08faf2fd919a74c1c19f8bbc03e8ab5e introduce a new label
prefix which preserves labels that would have been stripped out
by old versions of the Version Handler. This change had the
side effect of causing duplicate labels to be written in some
cases.

For example, an asset is labeled with gvhp_target-Editor (valid)
but the label is rewritten as gvh_target-Editor (legacy compatible
format) which causes two labels to be applied to the asset and
an unnecessary update of the asset database.

This change searches the current set of labels applied to an
asset and applies the appropriate prefix based upon the currently
applied labels to minimize the set of labels that are modified.

Bug: 150886091
Change-Id: I43c98064135c8242f283725a62c23257a645c895

Author: Stewart Miles

source/VersionHandlerImpl/src/VersionHandlerImpl.cs

@@ -559,13 +559,14 @@ private string CreateToken(string[] fieldPrefixes, string[] values) {
         /// <param name="fieldPrefixes">The first item of this list is used as the prefix.
         /// </param>
         /// <param name="values">Set of values to store with the field.</param>
+        /// <param name="currentLabels">Labels to search for the suitable prefix.</param>
         /// <param name="preserve">Always preserve these labels.</param>
         private static string[] CreateLabels(string[] fieldPrefixes, IEnumerable<string> values,
-                                             bool preserve = false) {
+                                             HashSet<string> currentLabels, bool preserve = false) {
             string prefix = fieldPrefixes[0];
             List<string> labels = new List<string>();
             foreach (var value in values) {
-                labels.Add(CreateLabel(prefix, value, preserve: preserve));
+                labels.Add(CreateLabel(prefix, value, currentLabels, preserve: preserve));
             }
 
             return labels.ToArray();
@@ -582,6 +583,23 @@ public static string CreateLabel(string prefix, string value, bool preserve = fa
             return (preserve ? LABEL_PREFIX_PRESERVE : LABEL_PREFIX) + prefix + value;
         }
 
+        /// <summary>
+        /// Create an asset label keeping the preservation in the supplied set if it already exists.
+        /// </summary>
+        /// <param name="prefix"> The field prefix to be applied to the label.
+        /// </param>
+        /// <param name="value">The value to store in the field</param>
+        /// <param name="currentLabels">Labels to search for the suitable prefix.</param>
+        /// <param name="preserve">Whether the label should be preserved.</param>
+        public static string CreateLabel(string prefix, string value, HashSet<string> currentLabels,
+                                         bool preserve = false) {
+            var legacyLabel = CreateLabel(prefix, value, false);
+            var preservedLabel = CreateLabel(prefix, value, true);
+            if (currentLabels.Contains(legacyLabel)) return legacyLabel;
+            if (currentLabels.Contains(preservedLabel)) return preservedLabel;
+            return preserve ? preservedLabel : legacyLabel;
+        }
+
         /// <summary>
         /// Determine whether this file is compatible with the editor.
         /// This is a special case as the editor isn't a "platform" covered
@@ -661,8 +679,8 @@ public void UpdateAssetLabels() {
                 return;
             }
             AssetImporter importer = AssetImporter.GetAtPath(filename);
-            var labels = new List<string>();
-            var currentLabels = new List<string>();
+            var labels = new HashSet<string>();
+            var currentLabels = new HashSet<string>();
             // Strip labels we're currently managing.
             foreach (string label in AssetDatabase.GetLabels(importer)) {
                 currentLabels.Add(label);
@@ -676,52 +694,56 @@ public void UpdateAssetLabels() {
             labels.Add(ASSET_LABEL);
             // Add labels for the metadata in this class.
             if (!String.IsNullOrEmpty(versionString)) {
-                labels.Add(CreateLabel(TOKEN_VERSION[0], versionString));
+                labels.Add(CreateLabel(TOKEN_VERSION[0], versionString, currentLabels));
             }
             if (targets != null && targets.Count > 0) {
-                labels.AddRange(CreateLabels(TOKEN_TARGETS, targets));
+                labels.UnionWith(CreateLabels(TOKEN_TARGETS, targets, currentLabels));
 
                 if (!isHandledByPluginImporter) {
                     labels.Add(ASSET_LABEL_RENAME_TO_DISABLE);
                 }
             }
             if (dotNetTargets != null && dotNetTargets.Count > 0) {
-                labels.AddRange(CreateLabels(TOKEN_DOTNET_TARGETS, dotNetTargets));
+                labels.UnionWith(CreateLabels(TOKEN_DOTNET_TARGETS, dotNetTargets, currentLabels));
             }
             if (!String.IsNullOrEmpty(linuxLibraryBasename)) {
-                labels.Add(CreateLabel(TOKEN_LINUX_LIBRARY_BASENAME[0], linuxLibraryBasename));
+                labels.Add(CreateLabel(TOKEN_LINUX_LIBRARY_BASENAME[0], linuxLibraryBasename,
+                                       currentLabels));
             }
             if (!String.IsNullOrEmpty(exportPath)) {
-                labels.Add(CreateLabel(TOKEN_EXPORT_PATH[0], exportPath, preserve: true));
+                labels.Add(CreateLabel(TOKEN_EXPORT_PATH[0], exportPath, currentLabels,
+                                       preserve: true));
             }
             if (isManifest) {
-                labels.Add(CreateLabel(TOKEN_MANIFEST[0], null));
+                labels.Add(CreateLabel(TOKEN_MANIFEST[0], null, currentLabels));
             }
             if (customManifestNames != null && customManifestNames.Count > 0) {
                 foreach (var indexAndName in customManifestNames) {
                     int order = indexAndName.Key + CUSTOM_MANIFEST_NAMES_FIRST_INDEX_OFFSET;
                     var name = indexAndName.Value;
                     if (order < CUSTOM_MANIFEST_NAMES_FIRST_INDEX_OFFSET) {
                         labels.Add(CreateLabel(TOKEN_MANIFEST_NAME[0], order.ToString() + name,
-                                               preserve: true));
+                                               currentLabels, preserve: true));
                     } else {
-                        labels.Add(CreateLabel(TOKEN_MANIFEST_NAME[0], name, preserve: true));
+                        labels.Add(CreateLabel(TOKEN_MANIFEST_NAME[0], name, currentLabels,
+                                               preserve: true));
                     }
                 }
             }
-            var uniqueLabels = new HashSet<string>(labels);
-            labels = new List<string>(uniqueLabels);
-            if (!uniqueLabels.SetEquals(new HashSet<string>(currentLabels))) {
-                currentLabels.Sort();
-                labels.Sort();
+            if (!labels.SetEquals(currentLabels)) {
+                var sortedLabels = new List<string>(labels);
+                var sortedCurrentLabels = new List<string>(currentLabels);
+                sortedCurrentLabels.Sort();
+                sortedLabels.Sort();
+                var labelsArray = sortedLabels.ToArray();
                 Log(String.Format("Changing labels of {0}\n" +
                                   "from: {1}\n" +
-                                  "to: {2}\n",
+                                  "to:   {2}\n",
                                   filename,
-                                  String.Join(", ", currentLabels.ToArray()),
-                                  String.Join(", ", labels.ToArray())),
+                                  String.Join(", ", sortedCurrentLabels.ToArray()),
+                                  String.Join(", ", labelsArray)),
                     verbose: true);
-                AssetDatabase.SetLabels(importer, labels.ToArray());
+                AssetDatabase.SetLabels(importer, labelsArray);
             }
         }