Merge JDK-8345139 into JDK-8315487

This way, we are syncing with the dependency of this PR.

Fix two minor conflicts in:
  src/java.base/share/classes/java/security/Provider.java

Author: franferrax

src/java.base/share/classes/java/security/Provider.java

@@ -453,7 +453,7 @@ public synchronized Set<Map.Entry<Object,Object>> entrySet() {
      * @since 1.2
      */
     @Override
-    public Set<Object> keySet() {
+    public synchronized Set<Object> keySet() {
         checkInitialized();
         return Collections.unmodifiableSet(super.keySet());
     }
@@ -465,7 +465,7 @@ public Set<Object> keySet() {
      * @since 1.2
      */
     @Override
-    public Collection<Object> values() {
+    public synchronized Collection<Object> values() {
         checkInitialized();
         return Collections.unmodifiableCollection(super.values());
     }
@@ -696,7 +696,8 @@ public synchronized Enumeration<Object> elements() {
     }
 
     // let javadoc show doc from superclass
-    public String getProperty(String key) {
+    @Override
+    public synchronized String getProperty(String key) {
         checkInitialized();
         return super.getProperty(key);
     }
@@ -763,8 +764,9 @@ private record MappingInfo(Service svc, ServiceKey algKey,
 
         // Auxiliary set to determine if a service on the services map was added
         // with the Legacy API. The absence of a service key on this set is an
-        // indication that the service was either not added or added with the
-        // Current API. Only algorithm service keys are added to this set.
+        // indication that the service was either not added to the services
+        // map (any API) or was added with the Current API. Only algorithm
+        // service keys are added to this set.
         private final Set<ServiceKey> legacySvcKeys;
 
         // Auxiliary map to keep track of the Properties map entries that
@@ -779,6 +781,9 @@ private record MappingInfo(Service svc, ServiceKey algKey,
         // added to this map.
         private final Map<ServiceKey, Map<UString, String>> serviceAttrProps;
 
+        /*
+         * Default constructor. Creates an empty services map for a Provider.
+         */
         ServicesMap() {
             allowedSet = new AtomicReference<>();
             notAllowedSet = new AtomicReference<>();
@@ -1039,9 +1044,10 @@ private void resolveKeyConflict(ServiceKey key,
                         opSucceeded = removeAliasLegacy(miByKey.algKey, key,
                                 keysToBeKept);
                     } else {
-                        // The service was added with the Current API. Overwrite
-                        // the alias entry on the services map without modifying
-                        // the service that is currently using it.
+                        // The service was added with the Current API. Once we
+                        // return to putService, the alias entry on the services
+                        // map will be overwritten without modifying the service
+                        // that is currently associated with.
 
                         // Remove any Properties map key entry because, if no
                         // longer used as an alias, the entry would not be
@@ -1179,7 +1185,7 @@ boolean putClassNameLegacy(ServiceKey key, String className,
                 String canonicalPropKey = propKey;
                 if (oldMi.svc != null) {
                     // The service exists. Get its Properties map entry. Note:
-                    // Services added through an alias or an attribute may don't
+                    // Services added through an alias or an attribute may not
                     // have one.
                     String oldPropKey = serviceProps.get(oldMi.algKey);
                     if (oldMi.algKey.equals(key)) {
@@ -1445,6 +1451,8 @@ private interface ServiceUpdateCallback {
          * The updated version of the service is put on the services map.
          * Algorithm and alias based entries pointing to the old version of the
          * service are overwritten.
+         *
+         * This method is invoked from the Legacy API only.
          */
         private boolean updateSvc(ServiceKey key,
                 ServiceUpdateCallback updateCb) {
@@ -1618,9 +1626,9 @@ private void implClear() {
     }
 
     private Object implRemove(Object key) {
-        Object oldValue = super.get(key);
-        return doLegacyOp(servicesMap, key, oldValue, null, OPType.REMOVE) ==
-                PropertiesMapAction.UPDATE ? super.remove(key) : oldValue;
+        Object value = super.get(key);
+        return doLegacyOp(servicesMap, key, value, null, OPType.REMOVE) ==
+                PropertiesMapAction.UPDATE ? super.remove(key) : value;
     }
 
     private boolean implRemove(Object key, Object value) {
@@ -1736,7 +1744,6 @@ private Object implPut(ServicesMap servicesMap, Object key, Object value) {
                 PropertiesMapAction.UPDATE ? super.put(key, value) : oldValue;
     }
 
-    // used as key in the serviceMap and legacyMap HashMaps
     private static final class ServiceKey {
         private final String type;
         private final String algorithm;
@@ -2188,16 +2195,19 @@ public static class Service {
         private Map<UString, String> attributes;
         private final EngineDescription engineDescription;
 
-        // For services added to a ServicesMap, their algorithm service key.
-        // This value derives from the algorithm field. For services (still)
-        // not added to a ServicesMap, value is null.
+        // This value is the algorithm service key when the service is added to
+        // the ServicesMap. Value is null otherwise.
         private ServiceKey algKey;
 
-        // For services added to a ServicesMap, this is a map from alias service
-        // keys to alias string values. Empty map if no aliases. While map
-        // entries derive from the aliases field, keys are not repeated
-        // (case-insensitive comparison) and not equal to the algorithm. For
-        // services (still) not added to a ServicesMap, value is an empty map.
+        // This map is empty if the service has no aliases or has not been
+        // registered in the ServicesMap. When the service has aliases and is
+        // registered in the ServicesMap, this information maps the alias
+        // ServiceKey to the string alias as originally defined in the service.
+        //
+        // The purpose for this map is both to keep references to alias
+        // ServiceKeys for reuse (i.e. we don't have to construct them from
+        // strings multiple times) and to facilitate alias string updates with
+        // different casing from the Legacy API.
         private Map<ServiceKey, String> aliasKeys;
 
         // Cache with the Providers filter decision for this service. Value is
@@ -2239,7 +2249,7 @@ public static class Service {
         private static final Class<?>[] CLASS0 = new Class<?>[0];
 
         /*
-         * Constructor used from the ServicesMap Legacy API.
+         * Constructor used by the ServicesMap Legacy API.
          */
         private Service(Provider provider, ServiceKey algKey) {
             assert algKey.algorithm.intern() == algKey.algorithm :
@@ -2255,7 +2265,7 @@ private Service(Provider provider, ServiceKey algKey) {
         }
 
         /*
-         * Copy constructor used from the ServicesMap Legacy API for the
+         * Copy constructor used by the ServicesMap Legacy API for the
          * copy-on-write strategy. This constructor is invoked after every
          * update to a service on the ServicesMap.
          */
@@ -2279,7 +2289,6 @@ private Service(Service svc) {
                 attributes = new HashMap<>(svc.attributes);
             }
             isAllowed = svc.isAllowed;
-            registered = false;
             if (svc.cipherTransformsAllowed != null) {
                 cipherTransformsAllowed = new ConcurrentHashMap<>(
                         svc.cipherTransformsAllowed);
@@ -2296,7 +2305,7 @@ private Service(Service svc) {
         }
 
         /*
-         * Methods used from the ServicesMap Legacy API to update a service.
+         * Methods used by the ServicesMap Legacy API to update a service.
          */
 
         private void addAliasKey(ServiceKey aliasKey) {
@@ -2375,37 +2384,14 @@ public Service(Provider provider, String type, String algorithm,
             if (attributes == null) {
                 this.attributes = Collections.emptyMap();
             } else {
-                this.attributes = new HashMap<>();
+                this.attributes = new HashMap<>(attributes.size(), 1.0f);
                 for (Map.Entry<String, String> entry : attributes.entrySet()) {
                     this.attributes.put(new UString(entry.getKey()),
                             entry.getValue());
                 }
             }
         }
 
-        /*
-         * When a Service is added to a ServicesMap with the Current API,
-         * service and alias keys must be generated. Currently used by
-         * ServicesMap::putService. Legacy API methods do not need to call:
-         * they generated the algorithm key at construction time and alias
-         * keys with Service::addAliasKey.
-         */
-        private void generateServiceKeys() {
-            if (algKey == null) {
-                assert (Object)aliasKeys == Collections.emptyMap() :
-                        "aliasKeys expected to be the empty map.";
-                algKey = new ServiceKey(type, algorithm, true);
-                aliasKeys = new HashMap<>(aliases.size());
-                for (String alias : aliases) {
-                    ServiceKey aliasKey = new ServiceKey(type, alias, true);
-                    if (!aliasKey.equals(algKey)) {
-                        aliasKeys.put(aliasKey, alias);
-                    }
-                }
-                aliasKeys = Collections.unmodifiableMap(aliasKeys);
-            }
-        }
-
         /*
          * Returns whether the service is allowed or not according to the
          * Providers filter. This decision is usually made when a service
@@ -2673,6 +2659,31 @@ public Object newInstance(Object constructorParameter)
             }
         }
 
+        /*
+         * When a Service is added to a ServicesMap with the Current API,
+         * service and alias keys must be generated. Currently used by
+         * ServicesMap::putService. Legacy API methods do not need to call:
+         * they generated the algorithm key at construction time and alias
+         * keys with Service::addAliasKey.
+         */
+        private void generateServiceKeys() {
+            if (algKey == null) {
+                assert (Object)aliasKeys == Collections.emptyMap() :
+                        "aliasKeys expected to be the empty map.";
+                algKey = new ServiceKey(type, algorithm, true);
+                if (!aliases.isEmpty()) {
+                    aliasKeys = new HashMap<>(aliases.size());
+                    for (String alias : aliases) {
+                        ServiceKey aliasKey = new ServiceKey(type, alias, true);
+                        if (!aliasKey.equals(algKey)) {
+                            aliasKeys.put(aliasKey, alias);
+                        }
+                    }
+                    aliasKeys = Collections.unmodifiableMap(aliasKeys);
+                }
+            }
+        }
+
         private Object newInstanceOf() throws Exception {
             Constructor<?> con = getDefaultConstructor();
             return con.newInstance(EMPTY);