Improve CleanupReference & add test

content/public/android/javatests/src/org/chromium/content/common/CleanupReferenceTest.java

+// Copyright 2013 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.content.common;
+
+import android.test.InstrumentationTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.chromium.base.test.util.Feature;
+import org.chromium.content.browser.test.util.Criteria;
+import org.chromium.content.browser.test.util.CriteriaHelper;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class CleanupReferenceTest extends InstrumentationTestCase {
+
+    private static AtomicInteger sObjectCount = new AtomicInteger();
+
+    private static class ReferredObject {
+
+        private CleanupReference mRef;
+
+        // Remember: this MUST be a static class, to avoid an implicit ref back to the
+        // owning ReferredObject instance which would defeat GC of that object.
+        private static class DestroyRunnable implements Runnable {
+            @Override
+            public void run() {
+                sObjectCount.decrementAndGet();
+            }
+        };
+
+        public ReferredObject() {
+            sObjectCount.incrementAndGet();
+            mRef = new CleanupReference(this, new DestroyRunnable());
+        }
+    }
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        sObjectCount.set(0);
+    }
+
+    @SmallTest
+    @Feature({"AndroidWebView"})
+    public void testCreateSingle() throws Throwable {
+        assertEquals(0, sObjectCount.get());
+
+        ReferredObject instance = new ReferredObject();
+        assertEquals(1, sObjectCount.get());
+
+        instance = null;
+        System.gc();

[Kristian Monsen, 2013/03/20 03:59:02]

Is this sure to work in the future? I think System.gc() is just a hint, and even
if a gc runs it might not want to collect this object. I wonder if it would work
with a non stop-the-world gc?

[joth, 2013/03/20 21:00:39]

Broadly, if it stops working in future this is probably something we'd want to
know about. The test failing will help us learn this.

Specifically about System.gc(), agree it's almost always wrong to depend on it,
but testing finalizer/ReferenceQueues this is one of the few times you basically
have to. (Example in
http://google-collections.googlecode.com/svn-history/r77/trunk/test/com/googl...
)

We poll for 3s waiting for the GC to take effect. Hopefully it always will.
If it did ignore this 'hint' in future, we could add a "new byte[10 billion]"
call too, as the VM must attempt GC before throwing OOM exception.

I'll add a comment.

+        assertTrue(CriteriaHelper.pollForCriteria(new Criteria() {
+            @Override
+            public boolean isSatisfied() {
+                return sObjectCount.get() == 0;
+            }
+        }));
+    }
+
+    @SmallTest
+    @Feature({"AndroidWebView"})
+    public void testCreateMany() throws Throwable {
+        assertEquals(0, sObjectCount.get());
+
+        final int INSTANCE_COUNT = 20;
+        ReferredObject[] instances = new ReferredObject[INSTANCE_COUNT];
+
+        for (int i = 0; i < INSTANCE_COUNT; ++i) {
+            instances[i] = new ReferredObject();
+            assertEquals(i + 1, sObjectCount.get());
+        }
+
+        instances = null;
+        System.gc();
+        assertTrue(CriteriaHelper.pollForCriteria(new Criteria() {
+            @Override
+            public boolean isSatisfied() {
+                return sObjectCount.get() == 0;
+            }
+        }));
+    }
+
+}