This change introduces a mechanism in Glide's BitmapPool to prevent reusing bitmaps from the pool if the size difference between the requested bitmap and the available bitmap exceeds certain thresholds. The thresholds are defined by a maximum byte limit and a maximum ratio of wasted bytes to requested bytes.

The GlideBuilder now includes methods to set these waste limits. The LruPoolStrategy implementations (SizeConfigStrategy and SizeStrategy) are updated to check for excessive waste before returning a bitmap from the pool. If a bitmap is deemed too wasteful, it is not reused, and null is returned instead.

PiperOrigin-RevId: 862444967

Author: falhassen

library/src/main/java/com/bumptech/glide/GlideBuilder.java

@@ -67,6 +67,9 @@ public RequestOptions build() {
   private boolean isActiveResourceRetentionAllowed;
   @Nullable private List<RequestListener<Object>> defaultRequestListeners;
 
+  private int bitmapPoolWasteLimit = 0;
+  private float bitmapPoolWasteRatio = 0.0f;
+
   /**
    * Sets the {@link com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool} implementation to use
    * to store and retrieve reused {@link android.graphics.Bitmap}s.
@@ -523,6 +526,12 @@ public GlideBuilder setMemoryCategoryInBackground(MemoryCategory memoryCategory)
     return this;
   }
 
+  public GlideBuilder setBitmapPoolWasteLimit(int wasteLimit, float wasteRatio) {
+    this.bitmapPoolWasteLimit = wasteLimit;
+    this.bitmapPoolWasteRatio = wasteRatio;
+    return this;
+  }
+
   /**
    * @deprecated This method does nothing. It will be hard coded and removed in a future release
    *     without further warning.
@@ -593,6 +602,7 @@ Glide build(
         bitmapPool = new BitmapPoolAdapter();
       }
     }
+    bitmapPool.setWasteLimit(bitmapPoolWasteLimit, bitmapPoolWasteRatio);
 
     if (arrayPool == null) {
       arrayPool = new LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());

library/src/main/java/com/bumptech/glide/load/engine/bitmap_recycle/AttributeStrategy.java

@@ -47,6 +47,11 @@ public int getSize(Bitmap bitmap) {
     return Util.getBitmapByteSize(bitmap);
   }
 
+  @Override
+  public void setWasteLimit(int wasteLimit, float wasteRatio) {
+    // Do nothing.
+  }
+
   @Override
   public String toString() {
     return "AttributeStrategy:\n  " + groupedMap;

library/src/main/java/com/bumptech/glide/load/engine/bitmap_recycle/BitmapPool.java

@@ -97,4 +97,13 @@ public interface BitmapPool {
    * @see android.content.ComponentCallbacks2
    */
   void trimMemory(int level);
+
+  /**
+   * Sets the waste limit for the pool.
+   *
+   * @param wasteLimit The maximum number of bytes that can be wasted in the pool.
+   * @param wasteRatio The maximum ratio of wasted bytes to requested bytes that can be wasted in
+   *     the pool.
+   */
+  void setWasteLimit(int wasteLimit, float wasteRatio);
 }

library/src/main/java/com/bumptech/glide/load/engine/bitmap_recycle/BitmapPoolAdapter.java

@@ -45,4 +45,9 @@ public void clearMemory() {
   public void trimMemory(int level) {
     // Do nothing.
   }
+
+  @Override
+  public void setWasteLimit(int wasteLimit, float wasteRatio) {
+    // Do nothing.
+  }
 }

library/src/main/java/com/bumptech/glide/load/engine/bitmap_recycle/LruBitmapPool.java

@@ -329,6 +329,10 @@ private static Set<Bitmap.Config> getDefaultAllowedConfigs() {
     return Collections.unmodifiableSet(configs);
   }
 
+  public void setWasteLimit(int wasteLimit, float wasteRatio) {
+    strategy.setWasteLimit(wasteLimit, wasteRatio);
+  }
+
   private interface BitmapTracker {
     void add(Bitmap bitmap);
 

library/src/main/java/com/bumptech/glide/load/engine/bitmap_recycle/LruPoolStrategy.java

@@ -17,4 +17,6 @@ interface LruPoolStrategy {
   String logBitmap(int width, int height, Bitmap.Config config);
 
   int getSize(Bitmap bitmap);
+
+  void setWasteLimit(int wasteLimit, float wasteRatio);
 }

library/src/main/java/com/bumptech/glide/load/engine/bitmap_recycle/SizeConfigStrategy.java

@@ -59,6 +59,15 @@ public class SizeConfigStrategy implements LruPoolStrategy {
   private final GroupedLinkedMap<Key, Bitmap> groupedMap = new GroupedLinkedMap<>();
   private final Map<Bitmap.Config, NavigableMap<Integer, Integer>> sortedSizes = new HashMap<>();
 
+  private int wasteLimit = 0;
+  private float wasteRatio = 0.0f;
+
+  private boolean isWasteful(int requestSize, int actualSize) {
+    int waste = actualSize - requestSize;
+    return (wasteLimit > 0 && waste >= wasteLimit)
+        || (wasteRatio > 0 && waste / (float) requestSize >= wasteRatio);
+  }
+
   @Override
   public void put(Bitmap bitmap) {
     int size = Util.getBitmapByteSize(bitmap);
@@ -79,9 +88,15 @@ public Bitmap get(int width, int height, Bitmap.Config config) {
 
     Bitmap result = groupedMap.get(bestKey);
     if (result != null) {
-      // Decrement must be called before reconfigure.
-      decrementBitmapOfSize(bestKey.size, result);
-      result.reconfigure(width, height, config);
+      // If the waste is too much, we put the bitmap back and return null.
+      if (isWasteful(size, bestKey.size)) {
+        groupedMap.put(bestKey, result);
+        result = null;
+      } else {
+        // Decrement must be called before reconfigure.
+        decrementBitmapOfSize(bestKey.size, result);
+        result.reconfigure(width, height, config);
+      }
     }
     return result;
   }
@@ -162,6 +177,12 @@ public int getSize(Bitmap bitmap) {
     return Util.getBitmapByteSize(bitmap);
   }
 
+  @Override
+  public void setWasteLimit(int wasteLimit, float wasteRatio) {
+    this.wasteLimit = wasteLimit;
+    this.wasteRatio = wasteRatio;
+  }
+
   @Override
   public String toString() {
     StringBuilder sb =

library/src/main/java/com/bumptech/glide/load/engine/bitmap_recycle/SizeStrategy.java

@@ -22,6 +22,15 @@ final class SizeStrategy implements LruPoolStrategy {
   private final GroupedLinkedMap<Key, Bitmap> groupedMap = new GroupedLinkedMap<>();
   private final NavigableMap<Integer, Integer> sortedSizes = new PrettyPrintTreeMap<>();
 
+  int wasteLimit = 0;
+  float wasteRatio = 0.0f;
+
+  private boolean isWasteful(int requestSize, int actualSize) {
+    int waste = actualSize - requestSize;
+    return (wasteLimit > 0 && waste >= wasteLimit)
+        || (wasteRatio > 0 && waste / (float) requestSize >= wasteRatio);
+  }
+
   @Override
   public void put(Bitmap bitmap) {
     int size = Util.getBitmapByteSize(bitmap);
@@ -49,8 +58,14 @@ public Bitmap get(int width, int height, Bitmap.Config config) {
     // lru pool
     final Bitmap result = groupedMap.get(key);
     if (result != null) {
-      result.reconfigure(width, height, config);
-      decrementBitmapOfSize(possibleSize);
+      // If the waste is too much, we put the bitmap back and return null.
+      if (isWasteful(size, possibleSize)) {
+        groupedMap.put(key, result);
+        return null;
+      } else {
+        result.reconfigure(width, height, config);
+        decrementBitmapOfSize(possibleSize);
+      }
     }
 
     return result;
@@ -92,6 +107,12 @@ public int getSize(Bitmap bitmap) {
     return Util.getBitmapByteSize(bitmap);
   }
 
+  @Override
+  public void setWasteLimit(int wasteLimit, float wasteRatio) {
+    this.wasteLimit = wasteLimit;
+    this.wasteRatio = wasteRatio;
+  }
+
   @Override
   public String toString() {
     return "SizeStrategy:\n  " + groupedMap + "\n" + "  SortedSizes" + sortedSizes;