OAK-11744 : removed usage of Guava's ImmutableList (#2320)

rishabhdaim · Rishabh Kumar · web-flow · commit 2ec6d67261bc · 2025-06-02T20:56:26.000+05:30
Co-authored-by: Rishabh Kumar &lt;diam@adobe.com&gt;
diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authentication/token/TokenConfigurationImpl.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authentication/token/TokenConfigurationImpl.java
@@ -16,7 +16,6 @@
  */
 package org.apache.jackrabbit.oak.security.authentication.token;
 
-import org.apache.jackrabbit.guava.common.collect.ImmutableList;
 import org.apache.jackrabbit.oak.api.Root;
 import org.apache.jackrabbit.oak.commons.collections.SetUtils;
 import org.apache.jackrabbit.oak.spi.commit.MoveTracker;
@@ -147,7 +146,7 @@ public String getName() {
     @Override
     public List<? extends ValidatorProvider> getValidators(@NotNull String workspaceName, @NotNull Set<Principal> principals, @NotNull MoveTracker moveTracker) {
         ValidatorProvider vp = new TokenValidatorProvider(getSecurityProvider().getParameters(UserConfiguration.NAME), getTreeProvider());
-        return ImmutableList.of(vp);
+        return List.of(vp);
     }
 
     @Override
diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeAccessControlManager.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeAccessControlManager.java
@@ -32,7 +32,6 @@
 import javax.jcr.security.AccessControlPolicyIterator;
 import javax.jcr.security.Privilege;
 
-import org.apache.jackrabbit.guava.common.collect.ImmutableList;
 import org.apache.jackrabbit.api.security.JackrabbitAccessControlManager;
 import org.apache.jackrabbit.api.security.JackrabbitAccessControlPolicy;
 import org.apache.jackrabbit.commons.iterator.AccessControlPolicyIteratorAdapter;
@@ -81,24 +80,23 @@ public Privilege[] getSupportedPrivileges(String absPath) throws RepositoryExcep
 
     @Override
     public AccessControlPolicy[] getPolicies(String absPath) throws RepositoryException {
-        ImmutableList.Builder<AccessControlPolicy> policies = ImmutableList.builder();
+        List<AccessControlPolicy> policies = new ArrayList<>();
         for (AccessControlManager acMgr : acMgrs) {
-            policies.add(acMgr.getPolicies(absPath));
+            policies.addAll(Arrays.asList(acMgr.getPolicies(absPath)));
         }
-        List<AccessControlPolicy> l = policies.build();
-        return l.toArray(new AccessControlPolicy[0]);
+        return policies.toArray(new AccessControlPolicy[0]);
     }
 
     @Override
     public AccessControlPolicy[] getEffectivePolicies(String absPath) throws RepositoryException {
-        ImmutableList.Builder<AccessControlPolicy> policies = ImmutableList.builder();
+        List<AccessControlPolicy> policies = new ArrayList<>();
         for (AccessControlManager acMgr : acMgrs) {
-            policies.add(acMgr.getEffectivePolicies(absPath));
+            policies.addAll(Arrays.asList(acMgr.getEffectivePolicies(absPath)));
             if (aggregationFilter.stop(acMgr, absPath)) {
                 break;
             }
         }
-        return policies.build().stream().distinct().toArray(AccessControlPolicy[]::new);
+        return policies.stream().distinct().toArray(AccessControlPolicy[]::new);
     }
 
     @Override
@@ -138,49 +136,46 @@ public void removePolicy(String absPath, AccessControlPolicy policy) throws Repo
     @NotNull
     @Override
     public JackrabbitAccessControlPolicy[] getApplicablePolicies(@NotNull Principal principal) throws RepositoryException {
-        ImmutableList.Builder<JackrabbitAccessControlPolicy> policies = ImmutableList.builder();
+        List<JackrabbitAccessControlPolicy> policies = new ArrayList<>();
         for (AccessControlManager acMgr : acMgrs) {
             if (acMgr instanceof JackrabbitAccessControlManager && acMgr instanceof PolicyOwner) {
-                policies.add(((JackrabbitAccessControlManager) acMgr).getApplicablePolicies(principal));
+                policies.addAll(Arrays.asList(((JackrabbitAccessControlManager) acMgr).getApplicablePolicies(principal)));
             }
         }
-        List<JackrabbitAccessControlPolicy> l = policies.build();
-        return l.toArray(new JackrabbitAccessControlPolicy[0]);
+        return policies.toArray(new JackrabbitAccessControlPolicy[0]);
     }
 
     @NotNull
     @Override
     public JackrabbitAccessControlPolicy[] getPolicies(@NotNull Principal principal) throws RepositoryException {
-        ImmutableList.Builder<JackrabbitAccessControlPolicy> policies = ImmutableList.builder();
+        List<JackrabbitAccessControlPolicy> policies = new ArrayList<>();
         for (AccessControlManager acMgr : acMgrs) {
             if (acMgr instanceof JackrabbitAccessControlManager) {
-                policies.add(((JackrabbitAccessControlManager) acMgr).getPolicies(principal));
+                policies.addAll(Arrays.asList(((JackrabbitAccessControlManager) acMgr).getPolicies(principal)));
             }
         }
-        List<JackrabbitAccessControlPolicy> l = policies.build();
-        return l.toArray(new JackrabbitAccessControlPolicy[0]);
+        return policies.toArray(new JackrabbitAccessControlPolicy[0]);
     }
 
     @NotNull
     @Override
     public AccessControlPolicy[] getEffectivePolicies(@NotNull Set<Principal> principals) throws RepositoryException {
-        ImmutableList.Builder<AccessControlPolicy> policies = ImmutableList.builder();
+        List<AccessControlPolicy> policies = new ArrayList<>();
         for (AccessControlManager acMgr : acMgrs) {
             if (acMgr instanceof JackrabbitAccessControlManager) {
                 JackrabbitAccessControlManager jAcMgr = (JackrabbitAccessControlManager) acMgr;
-                policies.add(jAcMgr.getEffectivePolicies(principals));
+                policies.addAll(Arrays.asList(jAcMgr.getEffectivePolicies(principals)));
                 if (aggregationFilter.stop(jAcMgr, principals)) {
                     break;
                 }
             }
         }
-        List<AccessControlPolicy> l = policies.build();
-        return l.toArray(new AccessControlPolicy[0]);
+        return policies.toArray(new AccessControlPolicy[0]);
     }
 
     @Override
     public @NotNull Iterator<AccessControlPolicy> getEffectivePolicies(@NotNull Set<Principal> principals, @Nullable String... absPaths) throws AccessDeniedException, AccessControlException, UnsupportedRepositoryOperationException, RepositoryException {
-        ImmutableList.Builder<Iterator<AccessControlPolicy>> iterators = ImmutableList.builder();
+        List<Iterator<AccessControlPolicy>> iterators = new ArrayList<>();
         for (AccessControlManager acMgr : acMgrs) {
             if (acMgr instanceof JackrabbitAccessControlManager) {
                 JackrabbitAccessControlManager jAcMgr = (JackrabbitAccessControlManager) acMgr;
@@ -190,6 +185,6 @@ public AccessControlPolicy[] getEffectivePolicies(@NotNull Set<Principal> princi
                 }
             }
         }
-        return IteratorUtils.chainedIterator(iterators.build().toArray(new Iterator[0]));
+        return IteratorUtils.chainedIterator(iterators.toArray(new Iterator[0]));
     }
 }
diff --git a/oak-security-spi/src/main/java/org/apache/jackrabbit/oak/spi/security/authorization/restriction/AbstractRestrictionProvider.java b/oak-security-spi/src/main/java/org/apache/jackrabbit/oak/spi/security/authorization/restriction/AbstractRestrictionProvider.java
@@ -21,6 +21,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -30,7 +31,6 @@
 import javax.jcr.Value;
 import javax.jcr.security.AccessControlException;
 
-import org.apache.jackrabbit.guava.common.collect.ImmutableList;
 import org.apache.jackrabbit.oak.api.PropertyState;
 import org.apache.jackrabbit.oak.api.Tree;
 import org.apache.jackrabbit.oak.api.Type;
@@ -85,7 +85,7 @@ public Restriction createRestriction(@Nullable String oakPath, @NotNull String o
         }
         PropertyState propertyState;
         if (requiredType.isArray()) {
-            propertyState = PropertyStates.createProperty(oakName, ImmutableList.of(value), tag);
+            propertyState = PropertyStates.createProperty(oakName, List.of(value), tag);
         } else {
             propertyState = PropertyStates.createProperty(oakName, value);
         }
diff --git a/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/RepositoryUpgrade.java b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/RepositoryUpgrade.java
@@ -31,6 +31,7 @@
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Collection;
 import java.util.Collections;
@@ -55,7 +56,6 @@
 import javax.jcr.nodetype.PropertyDefinitionTemplate;
 import javax.jcr.security.Privilege;
 
-import org.apache.jackrabbit.guava.common.collect.ImmutableList;
 import org.apache.jackrabbit.guava.common.collect.Lists;
 import org.apache.commons.collections4.bidimap.DualHashBidiMap;
 import org.apache.jackrabbit.JcrConstants;
@@ -772,7 +772,7 @@ private void copyCustomPrivileges(PrivilegeManager pMgr) throws RepositoryExcept
             while (it.hasNext()) {
                 Privilege aggrPriv = it.next();
 
-                List<String> aggrNames = Lists.transform(ImmutableList.copyOf(aggrPriv.getDeclaredAggregatePrivileges()),
+                List<String> aggrNames = Lists.transform(Arrays.asList(aggrPriv.getDeclaredAggregatePrivileges()),
                         input -> (input == null) ? null : input.getName());
                 if (allAggregatesRegistered(pMgr, aggrNames)) {
                     pMgr.registerPrivilege(aggrPriv.getName(), aggrPriv.isAbstract(), aggrNames.toArray(new String[aggrNames.size()]));

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,6 @@`
`32`	`32`	`import javax.jcr.security.AccessControlPolicyIterator;`
`33`	`33`	`import javax.jcr.security.Privilege;`
`34`	`34`
`35`		`-import org.apache.jackrabbit.guava.common.collect.ImmutableList;`
`36`	`35`	`import org.apache.jackrabbit.api.security.JackrabbitAccessControlManager;`
`37`	`36`	`import org.apache.jackrabbit.api.security.JackrabbitAccessControlPolicy;`
`38`	`37`	`import org.apache.jackrabbit.commons.iterator.AccessControlPolicyIteratorAdapter;`
`@@ -81,24 +80,23 @@ public Privilege[] getSupportedPrivileges(String absPath) throws RepositoryExcep`
`81`	`80`
`82`	`81`	`@Override`
`83`	`82`	`public AccessControlPolicy[] getPolicies(String absPath) throws RepositoryException {`
`84`		`- ImmutableList.Builder<AccessControlPolicy> policies = ImmutableList.builder();`
	`83`	`+ List<AccessControlPolicy> policies = new ArrayList<>();`
`85`	`84`	`for (AccessControlManager acMgr : acMgrs) {`
`86`		`- policies.add(acMgr.getPolicies(absPath));`
	`85`	`+ policies.addAll(Arrays.asList(acMgr.getPolicies(absPath)));`
`87`	`86`	`}`
`88`		`- List<AccessControlPolicy> l = policies.build();`
`89`		`- return l.toArray(new AccessControlPolicy[0]);`
	`87`	`+ return policies.toArray(new AccessControlPolicy[0]);`
`90`	`88`	`}`
`91`	`89`
`92`	`90`	`@Override`
`93`	`91`	`public AccessControlPolicy[] getEffectivePolicies(String absPath) throws RepositoryException {`
`94`		`- ImmutableList.Builder<AccessControlPolicy> policies = ImmutableList.builder();`
	`92`	`+ List<AccessControlPolicy> policies = new ArrayList<>();`
`95`	`93`	`for (AccessControlManager acMgr : acMgrs) {`
`96`		`- policies.add(acMgr.getEffectivePolicies(absPath));`
	`94`	`+ policies.addAll(Arrays.asList(acMgr.getEffectivePolicies(absPath)));`
`97`	`95`	`if (aggregationFilter.stop(acMgr, absPath)) {`
`98`	`96`	`break;`
`99`	`97`	`}`
`100`	`98`	`}`
`101`		`- return policies.build().stream().distinct().toArray(AccessControlPolicy[]::new);`
	`99`	`+ return policies.stream().distinct().toArray(AccessControlPolicy[]::new);`
`102`	`100`	`}`
`103`	`101`
`104`	`102`	`@Override`
`@@ -138,49 +136,46 @@ public void removePolicy(String absPath, AccessControlPolicy policy) throws Repo`
`138`	`136`	`@NotNull`
`139`	`137`	`@Override`
`140`	`138`	`public JackrabbitAccessControlPolicy[] getApplicablePolicies(@NotNull Principal principal) throws RepositoryException {`
`141`		`- ImmutableList.Builder<JackrabbitAccessControlPolicy> policies = ImmutableList.builder();`
	`139`	`+ List<JackrabbitAccessControlPolicy> policies = new ArrayList<>();`
`142`	`140`	`for (AccessControlManager acMgr : acMgrs) {`
`143`	`141`	`if (acMgr instanceof JackrabbitAccessControlManager && acMgr instanceof PolicyOwner) {`
`144`		`- policies.add(((JackrabbitAccessControlManager) acMgr).getApplicablePolicies(principal));`
	`142`	`+ policies.addAll(Arrays.asList(((JackrabbitAccessControlManager) acMgr).getApplicablePolicies(principal)));`
`145`	`143`	`}`
`146`	`144`	`}`
`147`		`- List<JackrabbitAccessControlPolicy> l = policies.build();`
`148`		`- return l.toArray(new JackrabbitAccessControlPolicy[0]);`
	`145`	`+ return policies.toArray(new JackrabbitAccessControlPolicy[0]);`
`149`	`146`	`}`
`150`	`147`
`151`	`148`	`@NotNull`
`152`	`149`	`@Override`
`153`	`150`	`public JackrabbitAccessControlPolicy[] getPolicies(@NotNull Principal principal) throws RepositoryException {`
`154`		`- ImmutableList.Builder<JackrabbitAccessControlPolicy> policies = ImmutableList.builder();`
	`151`	`+ List<JackrabbitAccessControlPolicy> policies = new ArrayList<>();`
`155`	`152`	`for (AccessControlManager acMgr : acMgrs) {`
`156`	`153`	`if (acMgr instanceof JackrabbitAccessControlManager) {`
`157`		`- policies.add(((JackrabbitAccessControlManager) acMgr).getPolicies(principal));`
	`154`	`+ policies.addAll(Arrays.asList(((JackrabbitAccessControlManager) acMgr).getPolicies(principal)));`
`158`	`155`	`}`
`159`	`156`	`}`
`160`		`- List<JackrabbitAccessControlPolicy> l = policies.build();`
`161`		`- return l.toArray(new JackrabbitAccessControlPolicy[0]);`
	`157`	`+ return policies.toArray(new JackrabbitAccessControlPolicy[0]);`
`162`	`158`	`}`
`163`	`159`
`164`	`160`	`@NotNull`
`165`	`161`	`@Override`
`166`	`162`	`public AccessControlPolicy[] getEffectivePolicies(@NotNull Set<Principal> principals) throws RepositoryException {`
`167`		`- ImmutableList.Builder<AccessControlPolicy> policies = ImmutableList.builder();`
	`163`	`+ List<AccessControlPolicy> policies = new ArrayList<>();`
`168`	`164`	`for (AccessControlManager acMgr : acMgrs) {`
`169`	`165`	`if (acMgr instanceof JackrabbitAccessControlManager) {`
`170`	`166`	`JackrabbitAccessControlManager jAcMgr = (JackrabbitAccessControlManager) acMgr;`
`171`		`- policies.add(jAcMgr.getEffectivePolicies(principals));`
	`167`	`+ policies.addAll(Arrays.asList(jAcMgr.getEffectivePolicies(principals)));`
`172`	`168`	`if (aggregationFilter.stop(jAcMgr, principals)) {`
`173`	`169`	`break;`
`174`	`170`	`}`
`175`	`171`	`}`
`176`	`172`	`}`
`177`		`- List<AccessControlPolicy> l = policies.build();`
`178`		`- return l.toArray(new AccessControlPolicy[0]);`
	`173`	`+ return policies.toArray(new AccessControlPolicy[0]);`
`179`	`174`	`}`
`180`	`175`
`181`	`176`	`@Override`
`182`	`177`	`public @NotNull Iterator<AccessControlPolicy> getEffectivePolicies(@NotNull Set<Principal> principals, @Nullable String... absPaths) throws AccessDeniedException, AccessControlException, UnsupportedRepositoryOperationException, RepositoryException {`
`183`		`- ImmutableList.Builder<Iterator<AccessControlPolicy>> iterators = ImmutableList.builder();`
	`178`	`+ List<Iterator<AccessControlPolicy>> iterators = new ArrayList<>();`
`184`	`179`	`for (AccessControlManager acMgr : acMgrs) {`
`185`	`180`	`if (acMgr instanceof JackrabbitAccessControlManager) {`
`186`	`181`	`JackrabbitAccessControlManager jAcMgr = (JackrabbitAccessControlManager) acMgr;`
`@@ -190,6 +185,6 @@ public AccessControlPolicy[] getEffectivePolicies(@NotNull Set<Principal> princi`
`190`	`185`	`}`
`191`	`186`	`}`
`192`	`187`	`}`
`193`		`- return IteratorUtils.chainedIterator(iterators.build().toArray(new Iterator[0]));`
	`188`	`+ return IteratorUtils.chainedIterator(iterators.toArray(new Iterator[0]));`
`194`	`189`	`}`
`195`	`190`	`}`