[Suggestions UI] Drop Bitmap references from articles under memory pressure.

base/android/java/src/org/chromium/base/ReferencePool.java

Index: base/android/java/src/org/chromium/base/ReferencePool.java
diff --git a/base/android/java/src/org/chromium/base/ReferencePool.java b/base/android/java/src/org/chromium/base/ReferencePool.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2569addfb3ae9a6e992f1e03509e9e9e06d5ccc
--- /dev/null
+++ b/base/android/java/src/org/chromium/base/ReferencePool.java
@@ -0,0 +1,62 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.base;
+
+import android.support.annotation.Nullable;
+
+import java.lang.ref.WeakReference;
+import java.util.WeakHashMap;
+
+/**
+ * A ReferencePool allows handing out typed references to objects ("payloads") that can be dropped
+ * in one batch ("drained"), e.g. under memory pressure. In contrast to {@link WeakReference}s,
+ * which drop their referents when they get garbage collected, a reference pool gives more precise
+ * control over when exactly it is drained.
+ *
+ * Internally it uses a {@link WeakHashMap} with the reference itself as a key to allow the payloads
+ * to be garbage collected regularly when the last reference goes away before the pool is drained.
+ */
+public class ReferencePool {
+    /**
+     * The underlying data storage. The wildcard type parameter allows using a single pool for
+     * references of any type.
+     */
+    private final WeakHashMap<Reference<?>, Object> mPool = new WeakHashMap<>();
+
+    /**
+     * A reference to an object in the pool. Will be nulled out when the pool has been drained.
+     * @param <T> The type of the object.
+     */
+    public class Reference<T> {
+        /**
+         * @return The referent, or null if the pool has been drained.
+         */
+        @SuppressWarnings("unchecked")
+        @Nullable
+        public T get() {
+            return (T) mPool.get(this);
+        }
+    }
+
+    /**
+     * @param <T> The type of the object.
+     * @param payload The payload to add to the pool.
+     * @return A new reference to the {@code payload}.
+     */
+    public <T> Reference<T> put(T payload) {
+        assert payload != null;
+        Reference<T> reference = new Reference<>();
+        mPool.put(reference, payload);

[Michael van Ouwerkerk, 2017/05/09 11:35:36]

As only the keys are weakly referenced by WeakHashMap, should this here put a
new WeakReference(payload) to make it robust against the payload->Reference
problem?

[Bernhard Bauer, 2017/05/09 12:37:17]

As discussed offline, the WeakHashMap usually is the only thing that holds a
reference to the payload, so using a WeakReference here would mean that the
payload would get immediately garbage-collected the next time. I added a comment
pointing out that using circular references might lead to leaks.

+        return reference;
+    }
+
+    /**
+     * Drains the pool, removing all references to objects in the pool and therefore allowing them
+     * to be garbage collected.
+     */
+    public void drain() {
+        mPool.clear();
+    }
+}