Add an experimental method to GlideExecutor.Builder to optionally add a decorator to all Runnables executed on that executor.

PiperOrigin-RevId: 807916271

Author: falhassen

library/src/main/java/com/bumptech/glide/load/engine/executor/GlideExecutor.java

@@ -21,6 +21,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
 
 /** A prioritized {@link ThreadPoolExecutor} for running jobs in Glide. */
 public final class GlideExecutor implements ExecutorService {
@@ -456,6 +457,7 @@ public static final class Builder {
 
     private String name;
     private long threadTimeoutMillis;
+    private Function<? super Runnable, ? extends Runnable> onExecuteDecorator;
 
     @Synthetic
     Builder(boolean preventNetworkOperations) {
@@ -514,21 +516,51 @@ public Builder setName(String name) {
       return this;
     }
 
+    /**
+     * Sets the decorator to be applied to each runnable executed by the executor.
+     *
+     * <p>This is an experimental method that may be removed without warning in a future version.
+     */
+    public Builder experimentalSetOnExecuteDecorator(
+        Function<? super Runnable, ? extends Runnable> onExecuteDecorator) {
+      this.onExecuteDecorator = onExecuteDecorator;
+      return this;
+    }
+
     /** Builds a new {@link GlideExecutor} with any previously specified options. */
     public GlideExecutor build() {
       if (TextUtils.isEmpty(name)) {
         throw new IllegalArgumentException(
             "Name must be non-null and non-empty, but given: " + name);
       }
-      ThreadPoolExecutor executor =
-          new ThreadPoolExecutor(
-              corePoolSize,
-              maximumPoolSize,
-              /* keepAliveTime= */ threadTimeoutMillis,
-              TimeUnit.MILLISECONDS,
-              new PriorityBlockingQueue<Runnable>(),
-              new DefaultThreadFactory(
-                  threadFactory, name, uncaughtThrowableStrategy, preventNetworkOperations));
+      ThreadFactory factory =
+          new DefaultThreadFactory(
+              threadFactory, name, uncaughtThrowableStrategy, preventNetworkOperations);
+      ThreadPoolExecutor executor;
+      if (onExecuteDecorator != null) {
+        executor =
+            new ThreadPoolExecutor(
+                corePoolSize,
+                maximumPoolSize,
+                /* keepAliveTime= */ threadTimeoutMillis,
+                TimeUnit.MILLISECONDS,
+                new PriorityBlockingQueue<>(),
+                factory) {
+              @Override
+              public void execute(@NonNull Runnable command) {
+                super.execute(onExecuteDecorator.apply(command));
+              }
+            };
+      } else {
+        executor =
+            new ThreadPoolExecutor(
+                corePoolSize,
+                maximumPoolSize,
+                /* keepAliveTime= */ threadTimeoutMillis,
+                TimeUnit.MILLISECONDS,
+                new PriorityBlockingQueue<>(),
+                factory);
+      }
 
       if (threadTimeoutMillis != NO_THREAD_TIMEOUT) {
         executor.allowCoreThreadTimeOut(true);

library/test/src/test/java/com/bumptech/glide/load/engine/executor/GlideExecutorTest.java

@@ -9,6 +9,7 @@
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
@@ -18,6 +19,70 @@
 @Config(sdk = ROBOLECTRIC_SDK)
 public class GlideExecutorTest {
 
+  @Test
+  public void testOnExecuteDecorator_isCalledAndCanDecorateRunnable() throws InterruptedException {
+    final CountDownLatch decoratorCalled = new CountDownLatch(1);
+    final CountDownLatch decoratedRunnableExecuted = new CountDownLatch(1);
+
+    GlideExecutor executor =
+        GlideExecutor.newDiskCacheBuilder()
+            .experimentalSetOnExecuteDecorator(
+                new Function<Runnable, Runnable>() {
+                  @Override
+                  public Runnable apply(Runnable runnable) {
+                    decoratorCalled.countDown();
+                    return new Runnable() {
+                      @Override
+                      public void run() {
+                        decoratedRunnableExecuted.countDown();
+                        runnable.run();
+                      }
+                    };
+                  }
+                })
+            .build();
+
+    final CountDownLatch originalRunnableExecuted = new CountDownLatch(1);
+    executor.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            originalRunnableExecuted.countDown();
+          }
+        });
+
+    assertThat(decoratorCalled.await(100, TimeUnit.MILLISECONDS)).isTrue();
+    assertThat(decoratedRunnableExecuted.await(100, TimeUnit.MILLISECONDS)).isTrue();
+    assertThat(originalRunnableExecuted.await(100, TimeUnit.MILLISECONDS)).isTrue();
+
+    executor.shutdown();
+    executor.awaitTermination(500, TimeUnit.MILLISECONDS);
+  }
+
+  @Test
+  public void testOnExecuteDecorator_notDecorated_decoratorNotCalled() throws InterruptedException {
+    final CountDownLatch decoratorCalled = new CountDownLatch(1);
+    final CountDownLatch decoratedRunnableExecuted = new CountDownLatch(1);
+
+    GlideExecutor executor = GlideExecutor.newDiskCacheBuilder().build();
+
+    final CountDownLatch originalRunnableExecuted = new CountDownLatch(1);
+    executor.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            originalRunnableExecuted.countDown();
+          }
+        });
+
+    assertThat(decoratorCalled.await(100, TimeUnit.MILLISECONDS)).isFalse();
+    assertThat(decoratedRunnableExecuted.await(100, TimeUnit.MILLISECONDS)).isFalse();
+    assertThat(originalRunnableExecuted.await(100, TimeUnit.MILLISECONDS)).isTrue();
+
+    executor.shutdown();
+    executor.awaitTermination(500, TimeUnit.MILLISECONDS);
+  }
+
   @Test
   public void testLoadsAreExecutedInOrder() throws InterruptedException {
     final List<Integer> resultPriorities = Collections.synchronizedList(new ArrayList<Integer>());