Merge pull request #480 from square/py/find_tracked_references

Add API for finding the list of tracked references.

Author: pyricau

leakcanary-analyzer/src/main/java/com/squareup/leakcanary/HeapAnalyzer.java

@@ -43,6 +43,7 @@
 import static com.squareup.leakcanary.HahaHelper.extendsThread;
 import static com.squareup.leakcanary.HahaHelper.fieldToString;
 import static com.squareup.leakcanary.HahaHelper.fieldValue;
+import static com.squareup.leakcanary.HahaHelper.hasField;
 import static com.squareup.leakcanary.HahaHelper.threadName;
 import static com.squareup.leakcanary.LeakTraceElement.Holder.ARRAY;
 import static com.squareup.leakcanary.LeakTraceElement.Holder.CLASS;
@@ -63,6 +64,36 @@ public HeapAnalyzer(ExcludedRefs excludedRefs) {
     this.excludedRefs = excludedRefs;
   }
 
+  public List<TrackedReference> findTrackedReferences(File heapDumpFile) {
+    if (!heapDumpFile.exists()) {
+      throw new IllegalArgumentException("File does not exist: " + heapDumpFile);
+    }
+    try {
+      HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
+      HprofParser parser = new HprofParser(buffer);
+      Snapshot snapshot = parser.parse();
+      deduplicateGcRoots(snapshot);
+
+      ClassObj refClass = snapshot.findClass(KeyedWeakReference.class.getName());
+      List<TrackedReference> references = new ArrayList<>();
+      for (Instance weakRef : refClass.getInstancesList()) {
+        List<ClassInstance.FieldValue> values = classInstanceValues(weakRef);
+        String key = asString(fieldValue(values, "key"));
+        String name =
+            hasField(values, "name") ? asString(fieldValue(values, "name")) : "(No name field)";
+        Instance instance = fieldValue(values, "referent");
+        if (instance != null) {
+          String className = getClassName(instance);
+          List<String> fields = describeFields(instance);
+          references.add(new TrackedReference(key, name, className, fields));
+        }
+      }
+      return references;
+    } catch (Throwable e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   /**
    * Searches the heap dump for a {@link KeyedWeakReference} instance with the corresponding key,
    * and then computes the shortest strong reference path from that instance to the GC roots.
@@ -112,8 +143,7 @@ void deduplicateGcRoots(Snapshot snapshot) {
     // Repopulate snapshot with unique GC roots.
     gcRoots.clear();
     uniqueRootMap.forEach(new TObjectProcedure<String>() {
-      @Override
-      public boolean execute(String key) {
+      @Override public boolean execute(String key) {
         return gcRoots.add(uniqueRootMap.get(key));
       }
     });
@@ -250,37 +280,16 @@ private LeakTraceElement buildLeakElement(LeakNode node) {
     LeakTraceElement.Holder holderType;
     String className;
     String extra = null;
-    List<String> fields = new ArrayList<>();
+    List<String> fields = describeFields(holder);
+
+    className = getClassName(holder);
+
     if (holder instanceof ClassObj) {
-      ClassObj classObj = (ClassObj) holder;
       holderType = CLASS;
-      className = classObj.getClassName();
-      for (Map.Entry<Field, Object> entry : classObj.getStaticFieldValues().entrySet()) {
-        Field field = entry.getKey();
-        Object value = entry.getValue();
-        fields.add("static " + field.getName() + " = " + value);
-      }
     } else if (holder instanceof ArrayInstance) {
-      ArrayInstance arrayInstance = (ArrayInstance) holder;
       holderType = ARRAY;
-      className = arrayInstance.getClassObj().getClassName();
-      if (arrayInstance.getArrayType() == Type.OBJECT) {
-        Object[] values = arrayInstance.getValues();
-        for (int i = 0; i < values.length; i++) {
-          fields.add("[" + i + "] = " + values[i]);
-        }
-      }
     } else {
-      ClassInstance classInstance = (ClassInstance) holder;
       ClassObj classObj = holder.getClassObj();
-      for (Map.Entry<Field, Object> entry : classObj.getStaticFieldValues().entrySet()) {
-        fields.add("static " + fieldToString(entry));
-      }
-      for (ClassInstance.FieldValue field : classInstance.getValues()) {
-        fields.add(fieldToString(field));
-      }
-      className = classObj.getClassName();
-
       if (extendsThread(classObj)) {
         holderType = THREAD;
         String threadName = threadName(holder);
@@ -316,6 +325,52 @@ private LeakTraceElement buildLeakElement(LeakNode node) {
         fields);
   }
 
+  private List<String> describeFields(Instance instance) {
+    List<String> fields = new ArrayList<>();
+
+    if (instance instanceof ClassObj) {
+      ClassObj classObj = (ClassObj) instance;
+      for (Map.Entry<Field, Object> entry : classObj.getStaticFieldValues().entrySet()) {
+        Field field = entry.getKey();
+        Object value = entry.getValue();
+        fields.add("static " + field.getName() + " = " + value);
+      }
+    } else if (instance instanceof ArrayInstance) {
+      ArrayInstance arrayInstance = (ArrayInstance) instance;
+      if (arrayInstance.getArrayType() == Type.OBJECT) {
+        Object[] values = arrayInstance.getValues();
+        for (int i = 0; i < values.length; i++) {
+          fields.add("[" + i + "] = " + values[i]);
+        }
+      }
+    } else {
+      ClassObj classObj = instance.getClassObj();
+      for (Map.Entry<Field, Object> entry : classObj.getStaticFieldValues().entrySet()) {
+        fields.add("static " + fieldToString(entry));
+      }
+      ClassInstance classInstance = (ClassInstance) instance;
+      for (ClassInstance.FieldValue field : classInstance.getValues()) {
+        fields.add(fieldToString(field));
+      }
+    }
+    return fields;
+  }
+
+  private String getClassName(Instance instance) {
+    String className;
+    if (instance instanceof ClassObj) {
+      ClassObj classObj = (ClassObj) instance;
+      className = classObj.getClassName();
+    } else if (instance instanceof ArrayInstance) {
+      ArrayInstance arrayInstance = (ArrayInstance) instance;
+      className = arrayInstance.getClassObj().getClassName();
+    } else {
+      ClassObj classObj = instance.getClassObj();
+      className = classObj.getClassName();
+    }
+    return className;
+  }
+
   private long since(long analysisStartNanoTime) {
     return NANOSECONDS.toMillis(System.nanoTime() - analysisStartNanoTime);
   }

leakcanary-analyzer/src/main/java/com/squareup/leakcanary/TrackedReference.java

@@ -0,0 +1,31 @@
+package com.squareup.leakcanary;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * An instance tracked by a {@link KeyedWeakReference} that hadn't been cleared when the
+ * heap was dumped. May or may not point to a leaking reference.
+ */
+public class TrackedReference {
+
+  /** Corresponds to {@link KeyedWeakReference#key}. */
+  public final String key;
+
+  /** Corresponds to {@link KeyedWeakReference#name}. */
+  public final String name;
+
+  /** Class of the tracked instance. */
+  public final String className;
+
+  /** List of all fields (member and static) for that instance. */
+  public final List<String> fields;
+
+  public TrackedReference(String key, String name, String className, List<String> fields) {
+    this.key = key;
+    this.name = name;
+    this.className = className;
+    this.fields = Collections.unmodifiableList(new ArrayList<>(fields));
+  }
+}

leakcanary-analyzer/src/test/java/com/squareup/leakcanary/HeapAnalyzerTest.java

@@ -13,11 +13,11 @@
 
 import static com.squareup.haha.perflib.RootType.NATIVE_STATIC;
 import static com.squareup.haha.perflib.RootType.SYSTEM_CLASS;
+import static com.squareup.leakcanary.TestUtil.NO_EXCLUDED_REFS;
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class HeapAnalyzerTest {
-  private static final ExcludedRefs NO_EXCLUDED_REFS = null;
   private static final List<RootObj> DUP_ROOTS =
           asList(new RootObj(SYSTEM_CLASS, 6L),
                   new RootObj(SYSTEM_CLASS, 5L),

leakcanary-analyzer/src/test/java/com/squareup/leakcanary/TestUtil.java

@@ -17,17 +17,20 @@
 
 import java.io.File;
 import java.net.URL;
+import java.util.List;
 
 final class TestUtil {
 
+  public static final ExcludedRefs NO_EXCLUDED_REFS = ExcludedRefs.builder().build();
+
   enum HeapDumpFile {
     ASYNC_TASK("leak_asynctask.hprof", "dc983a12-d029-4003-8890-7dd644c664c5"),
     ASYNC_TASK_MPREVIEW2("leak_asynctask_mpreview2.hprof", "1114018e-e154-435f-9a3d-da63ae9b47fa"),
     ASYNC_TASK_M_POSTPREVIEW2("leak_asynctask_m_postpreview2.hprof",
         "25ae1778-7c1d-4ec7-ac50-5cce55424069");
 
-    private final String filename;
-    private final String referenceKey;
+    public final String filename;
+    public final String referenceKey;
 
     HeapDumpFile(String filename, String referenceKey) {
       this.filename = filename;
@@ -42,6 +45,12 @@ static File fileFromName(String filename) {
     return new File(url.getPath());
   }
 
+  static List<TrackedReference> findTrackedReferences(HeapDumpFile heapDumpFile) {
+    File file = fileFromName(heapDumpFile.filename);
+    HeapAnalyzer heapAnalyzer = new HeapAnalyzer(NO_EXCLUDED_REFS);
+    return heapAnalyzer.findTrackedReferences(file);
+  }
+
   static AnalysisResult analyze(HeapDumpFile heapDumpFile, ExcludedRefs.BuilderWithParams excludedRefs) {
     File file = fileFromName(heapDumpFile.filename);
     String referenceKey = heapDumpFile.referenceKey;

leakcanary-analyzer/src/test/java/com/squareup/leakcanary/TrackedReferencesTest.java

@@ -0,0 +1,26 @@
+package com.squareup.leakcanary;
+
+import java.util.List;
+import org.junit.Test;
+
+import static com.squareup.leakcanary.TestUtil.HeapDumpFile.ASYNC_TASK;
+import static com.squareup.leakcanary.TestUtil.HeapDumpFile.ASYNC_TASK_MPREVIEW2;
+import static com.squareup.leakcanary.TestUtil.HeapDumpFile.ASYNC_TASK_M_POSTPREVIEW2;
+import static com.squareup.leakcanary.TestUtil.findTrackedReferences;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TrackedReferencesTest {
+
+  @Test public void findsExpectedRef() {
+    List<TrackedReference> trackedReferences = findTrackedReferences(ASYNC_TASK_M_POSTPREVIEW2);
+    assertThat(trackedReferences).hasSize(1);
+    TrackedReference firstRef = trackedReferences.get(0);
+    assertThat(firstRef.key).isEqualTo(ASYNC_TASK_M_POSTPREVIEW2.referenceKey);
+    assertThat(firstRef.className).isEqualTo("com.example.leakcanary.MainActivity");
+  }
+
+  @Test public void findsSeveralRefs() {
+    List<TrackedReference> trackedReferences = findTrackedReferences(ASYNC_TASK);
+    assertThat(trackedReferences).hasSize(2);
+  }
+}