Revert of android: Switch CleanupReference to PhantomReference

content/public/android/java/src/org/chromium/content/common/CleanupReference.java

 // Copyright 2012 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.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.TraceEvent;
 
-import java.lang.ref.PhantomReference;
 import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
 import java.util.HashSet;
 import java.util.Set;
 
 /**
  * Handles running cleanup tasks when an object becomes eligible for GC. Cleanup tasks
  * are always executed on the main thread. In general, classes should not have
  * finalizers and likewise should not use this class for the same reasons. The
  * exception is where public APIs exist that require native side resources to be
  * cleaned up in response to java side GC of API objects. (Private/internal
  * interfaces should always favor explicit resource releases / destroy()
  * protocol for this rather than depend on GC to trigger native cleanup).
- *
- * NOTE Using PhantonReference instead of WeakReference is required for correctness.
- * WeakReferences are enqueued before finalizers are called, and finalizers can
- * resurrect the referent object. PhantomReference does delay clean up more compared
- * to WeakReference.
+ * NOTE this uses WeakReference rather than PhantomReference, to avoid delaying the
+ * cleanup processing until after finalizers (if any) have run. In general usage of
+ * this class indicates the client does NOT use finalizers anyway (Good), so this should
+ * not be a visible difference in practice.
  */
-public class CleanupReference extends PhantomReference<Object> {
+public class CleanupReference extends WeakReference<Object> {
     private static final String TAG = "cr.CleanupReference";
 
     private static final boolean DEBUG = false;  // Always check in as false!
 
     // The VM will enqueue CleanupReference instance onto sGcQueue when it becomes eligible for
     // garbage collection (i.e. when all references to the underlying object are nullified).
     // |sReaperThread| processes this queue by forwarding the references on to the UI thread
     // (via REMOVE_REF message) to perform cleanup.
     private static ReferenceQueue<Object> sGcQueue = new ReferenceQueue<Object>();
     private static Object sCleanupMonitor = new Object();
@@ skipping 116 matching lines @@
         if (DEBUG) Log.d(TAG, "runCleanupTaskInternal");
         sRefs.remove(this);
         if (mCleanupTask != null) {
             if (DEBUG) Log.i(TAG, "--- CLEANING ONE REF");
             mCleanupTask.run();
             mCleanupTask = null;
         }
         clear();
     }
 }