Changes StackTraceDeobfuscator to abstract and provide various factory methods.

This change will remove the need for extending StackTraceObfusctor most of the
time as in almost all scenarios it is extended to get the symbol map from jar
through the class loader (which makes sense).
Also a factory is provided to get the symbol map from the file system. For all
other cases, developers can construct the deobfuscator with a URL path or extend
the class to override openInputStream method.

Change-Id: I562e052caef8da7f3434319cf11b8984bc347fe5
Review-Link: https://gwt-review.googlesource.com/#/c/2270/

Review by: skybrian@google.com

git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@11565 8db76d5a-ed1c-0410-87a9-c151d255dfc7

Author: goktug@google.com

user/src/com/google/gwt/core/server/impl/StackTraceDeobfuscator.java

@@ -25,6 +25,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
+import java.net.URL;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -45,7 +46,48 @@
  * directory is written. By default, the final <code>symbolMaps</code> directory is
  * <code>war/WEB-INF/deploy/<i>yourmodulename</i>/symbolMaps/</code>.
  */
-public class StackTraceDeobfuscator {
+public abstract class StackTraceDeobfuscator {
+
+  /**
+   * Creates a deobfuscator that loads symbol and source map files under given resource path. Uses
+   * StackTraceObfuscator's {@link ClassLoader}.
+   */
+  public static StackTraceDeobfuscator fromResource(String symbolMapsPath) {
+    final String basePath = symbolMapsPath.endsWith("/") ? symbolMapsPath : symbolMapsPath + "/";
+    final ClassLoader classLoader = StackTraceDeobfuscator.class.getClassLoader();
+    return new StackTraceDeobfuscator() {
+      protected InputStream openInputStream(String fileName) throws IOException {
+        String filePath = basePath + fileName;
+        InputStream inputStream = classLoader.getResourceAsStream(filePath);
+        if (inputStream == null) {
+          throw new IOException("Missing resource: " + filePath);
+        }
+        return inputStream;
+      }
+    };
+  }
+
+  /**
+   * Creates a deobfuscator that loads symbol and source map files from the given directory.
+   */
+  public static StackTraceDeobfuscator fromFileSystem(final String symbolMapsDirectory) {
+    return new StackTraceDeobfuscator() {
+      protected InputStream openInputStream(String fileName) throws IOException {
+        return new FileInputStream(new File(symbolMapsDirectory, fileName));
+      }
+    };
+  }
+
+  /**
+   * Creates a deobfuscator that loads symbol and source map files beneath the given URL.
+   */
+  public static StackTraceDeobfuscator fromUrl(final URL urlPath) {
+    return new StackTraceDeobfuscator() {
+      protected InputStream openInputStream(String fileName) throws IOException {
+        return new URL(urlPath, fileName).openStream();
+      }
+    };
+  }
 
   /**
    * A cache that maps obfuscated symbols to arbitrary non-null string values. The cache can assume
@@ -105,36 +147,16 @@ Map<String, String> getAll(String strongName, Set<String> symbols) {
   private static final int LINE_NUMBER_UNKNOWN = -1;
   private static final String SYMBOL_DATA_UNKNOWN = "";
 
-  private final boolean lazyLoad;
-  private final File symbolMapsDirectory;
   private final Map<String, SourceMapping> sourceMaps = new HashMap<String, SourceMapping>();
   private final SymbolCache symbolCache = new SymbolCache();
+  private boolean lazyLoad = false;
 
   /**
-   * Creates a deobfuscator that loads symbol map files from the given directory. Symbol maps are
-   * generated into the location specified by the GWT compiler <code>-deploy</code> command line
-   * argument.
-   *
-   * @param symbolMapsDirectory the <code>symbolMaps</code> directory, with or without trailing
-   *        directory separator character
+   * If set to {@code true}, only symbols requested to be deobfuscated are cached and the rest is
+   * discarded. This provides a large memory savings at the expense of occasional extra disk reads.
+   * Note that, this will only have effect on symbol maps that haven't been fully loaded yet.
    */
-  public StackTraceDeobfuscator(String symbolMapsDirectory) {
-    this(symbolMapsDirectory, false);
-  }
-
-  /**
-   * Creates a deobfuscator that loads symbol map files from the given directory. Symbol maps are
-   * generated into the location specified by the GWT compiler <code>-deploy</code> command line
-   * argument.
-   *
-   * @param symbolMapsDirectory the <code>symbolMaps</code> directory, with or without trailing
-   *        directory separator character. Usually this directory will include files with .symbolmap
-            or .json extensions.
-   * @param lazyLoad if true, only symbols requested to be deobfuscated are cached. This provides a
-   *        large memory savings at the expense of occasional extra disk reads.
-   */
-  public StackTraceDeobfuscator(String symbolMapsDirectory, boolean lazyLoad) {
-    this.symbolMapsDirectory = new File(symbolMapsDirectory);
+  public void setLazyLoad(boolean lazyLoad) {
     this.lazyLoad = lazyLoad;
   }
 
@@ -293,26 +315,30 @@ public final StackTraceElement resymbolize(StackTraceElement ste, String strongN
 
   protected InputStream getSourceMapInputStream(String permutationStrongName, int fragmentNumber)
       throws IOException {
-    String filename = symbolMapsDirectory.getCanonicalPath()
-        + File.separatorChar + permutationStrongName + "_sourceMap" + fragmentNumber + ".json";
-    return new FileInputStream(filename);
+    return openInputStream(permutationStrongName + "_sourceMap" + fragmentNumber + ".json");
   }
 
   /**
    * Retrieves a new {@link InputStream} for the given permutation strong name. This implementation,
    * which subclasses may override, returns a {@link InputStream} for the <code>
-   * <i>permutation-strong-name</i>.symbolMap</code> file in the <code>symbolMaps</code> directory.
+   * <i>permutation-strong-name</i>.symbolMap</code> file.
    *
    * @param permutationStrongName the GWT permutation strong name
    * @return a new {@link InputStream}
    */
-  protected InputStream getSymbolMapInputStream(String permutationStrongName)
-      throws IOException {
-    String filename = symbolMapsDirectory.getCanonicalPath()
-        + File.separatorChar + permutationStrongName + ".symbolMap";
-    return new FileInputStream(filename);
+  protected InputStream getSymbolMapInputStream(String permutationStrongName) throws IOException {
+    return openInputStream(permutationStrongName + ".symbolMap");
   }
 
+  /**
+   * Opens a new {@link InputStream} for a symbol or source map file.
+   *
+   * @param fileName name of the symbol or source map file
+   * @return an input stream for reading the file (doesn't need to be buffered).
+   * @exception IOException if an I/O error occurs while creating the input stream.
+   */
+  protected abstract InputStream openInputStream(String fileName) throws IOException;
+
   private SourceMapping loadSourceMap(String permutationStrongName, int fragmentId) {
     SourceMapping toReturn = sourceMaps.get(permutationStrongName + fragmentId);
     if (toReturn == null) {

user/src/com/google/gwt/logging/server/StackTraceDeobfuscator.java

@@ -39,8 +39,7 @@ public class StackTraceDeobfuscator extends com.google.gwt.core.server.impl.Stac
    *                            directory separator character
    */
   public StackTraceDeobfuscator(String symbolMapsDirectory) {
-    super(symbolMapsDirectory);
-    setSymbolMapsDirectory(symbolMapsDirectory);
+    this(symbolMapsDirectory, false);
   }
 
   /**
@@ -54,7 +53,7 @@ public StackTraceDeobfuscator(String symbolMapsDirectory) {
    *                 a large memory savings at the expense of occasional extra disk reads.
    */
   public StackTraceDeobfuscator(String symbolMapsDirectory, boolean lazyLoad) {
-    super(symbolMapsDirectory, lazyLoad);
+    setLazyLoad(lazyLoad);
     setSymbolMapsDirectory(symbolMapsDirectory);
   }
 
@@ -96,17 +95,7 @@ public void setSymbolMapsDirectory(String symbolMapsDirectory) {
     this.symbolMapsDirectory = new File(symbolMapsDirectory);
   }
 
-  protected InputStream getSourceMapInputStream(String permutationStrongName, int fragmentNumber)
-      throws IOException {
-    String filename = symbolMapsDirectory.getCanonicalPath()
-        + File.separatorChar + permutationStrongName + "_sourceMap" + fragmentNumber + ".json";
-    return new FileInputStream(filename);
-  }
-
-  protected InputStream getSymbolMapInputStream(String permutationStrongName)
-      throws IOException {
-    String filename = symbolMapsDirectory.getCanonicalPath()
-        + File.separatorChar + permutationStrongName + ".symbolMap";
-    return new FileInputStream(filename);
+  protected InputStream openInputStream(String fileName) throws IOException {
+    return new FileInputStream(new File(symbolMapsDirectory, fileName));
   }
 }