Add experimental GWT.unloadModule() function.

Enable via <set-property name="gwt.unloadEnabled" value="true"/>
Invoke via window.__gwt_activeModules[moduleName].unloadModule().

Attempts to do the following:
1) Cleanup all outstanding non-primitive properties from $wnd
2) Remove all registered event listeners
3) detach all widgets from rootpanel
4) Cancel any continuously running timers, I/Os in progress, etc
5) Delete all code from the iframe scope (window != $wnd)
6) erase registration from __gwt_activeModules and null out nocache.js module function
7) Remove iframe hosting the module (if present)

Even with all of this cleanup, Chrome's heap profiler still shows leaks on the simplest modules. This is a work in progress to support portal-like services that want to load/unload many GWT modules within a long running page.

Currently, IE paths which use attachEvent() have not been patched.

By default, support is disabled and there should only be a negligible impact on codesize.

Review at http://gwt-code-reviews.appspot.com/1827804

Review by: [email protected]

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

Author: [email protected]

user/src/com/google/gwt/core/Core.gwt.xml

@@ -35,6 +35,15 @@
   <inherits name="com.google.gwt.core.XSLinker" />
   <inherits name="com.google.gwt.core.CrossSiteIframeLinker" />
 
+  <!-- When true, compiles in support for GWT.unloadModule(), otherwise it is a no-op. -->
+  <define-property name="gwt.unloadEnabled" values="false, true"/>
+  <set-property name="gwt.unloadEnabled" value="false"/>
+
+  <replace-with class="com.google.gwt.core.client.impl.UnloadSupportEnabled">
+      <when-property-is name="gwt.unloadEnabled" value="true"/>
+      <when-type-is class="com.google.gwt.core.client.impl.UnloadSupport"/>
+  </replace-with>
+
   <define-linker name="soycReport" class="com.google.gwt.core.linker.SoycReportLinker" />
   <define-linker name="symbolMaps" class="com.google.gwt.core.linker.SymbolMapsLinker" />
 

user/src/com/google/gwt/core/client/GWT.java

@@ -85,6 +85,10 @@ public static <T> T create(Class<?> classLiteral) {
     return com.google.gwt.core.shared.GWT.<T>create(classLiteral);
   }
 
+  public static void exportUnloadModule() {
+      Impl.exportUnloadModule();
+  }
+
   /**
    * Gets the URL prefix of the hosting page, useful for prepending to relative
    * paths of resources which may be relative to the host page. Typically, you
@@ -291,4 +295,15 @@ static void setBridge(GWTBridge bridge) {
   private static native String getVersion0() /*-{
     return $gwt_version;
   }-*/;
+
+  /**
+   * If enabled via &lt;set-property name="gwt.unloadEnabled" value="true"/> invoking this method causes the module
+   * to be removed from memory and all {@link com.google.gwt.core.client.impl.Disposable} instances to be
+   * cleaned up. This method is not typically called by the GWT module itself, but exported so that another module
+   * may call it. 
+   * @see com.google.gwt.core.client.GWT#exportUnloadModule() 
+   */
+  private static void unloadModule() {
+    Impl.unloadModule();
+  }
 }

user/src/com/google/gwt/core/client/impl/Disposable.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.core.client.impl;
+
+/**
+ * Disposable objects are registered to be called when GWT.unloadModule() is invoked allowing a GWT module to clean
+ * up danging DOM references and other exported or leaking references.
+ * @see Impl#scheduleDispose
+ */
+public interface Disposable {
+  void dispose();
+}

user/src/com/google/gwt/core/client/impl/Impl.java

@@ -26,6 +26,8 @@
  */
 public final class Impl {
 
+  public static boolean moduleUnloaded = false;
+
   private static final int WATCHDOG_ENTRY_DEPTH_CHECK_INTERVAL_MS = 2000;
 
   /**
@@ -44,6 +46,25 @@ public final class Impl {
    */
   private static int watchdogEntryDepthTimerId = -1;
 
+  private static UnloadSupport unloadSupport = GWT.isScript() ?
+      (UnloadSupport) GWT.create(UnloadSupport.class) : new UnloadSupport();
+
+  static {
+     exportUnloadModule();
+  }
+
+  public static void clearInterval(int timerId) {
+    unloadSupport.clearInterval(timerId);
+  }
+
+  public static void clearTimeout(int timerId) {
+    unloadSupport.clearTimeout(timerId);
+  }
+
+  public static void dispose(Disposable d) {
+    unloadSupport.dispose(d);
+  }
+
   /**
    * This method should be used whenever GWT code is entered from a JS context
    * and there is no GWT code in the same module on the call stack. Examples
@@ -58,7 +79,7 @@ public final class Impl {
    * The function passed to this method will be invoked via
    * <code>Function.apply()</code> with the current <code>this</code> value and
    * the invocation arguments passed to <code>$entry</code>.
-   * 
+   *
    * @param jsFunction a JS function to invoke, which is typically a JSNI
    *          reference to a static Java method
    * @return the value returned when <code>jsFunction</code> is invoked, or
@@ -79,6 +100,10 @@ public static native JavaScriptObject entry(JavaScriptObject jsFunction) /*-{
     };
   }-*/;
 
+  public static void exportUnloadModule() {
+    unloadSupport.exportUnloadModule();
+  }
+
   /**
    * Gets an identity-based hash code on the passed-in Object by adding an
    * expando. This method should not be used with <code>null</code> or any
@@ -134,7 +159,7 @@ public static native String getModuleName() /*-{
    * Returns the obfuscated name of members in the compiled output. This is a
    * thin wrapper around JNameOf AST nodes and is therefore meaningless to
    * implement in Development Mode.
-   * 
+   *
    * @param jsniIdent a string literal specifying a type, field, or method. Raw
    *          type names may also be used to obtain the name of the type's seed
    *          function.
@@ -193,6 +218,10 @@ public static boolean isEntryOnStack() {
     return entryDepth > 0;
   }
 
+  public static boolean isModuleUnloaded() {
+    return moduleUnloaded;
+  }
+
   /**
    * Indicates if <code>$entry</code> is present on the stack more than once.
    */
@@ -213,6 +242,25 @@ public static native JavaScriptObject registerEntry() /*-{
     }
   }-*/;
 
+  public static void scheduleDispose(Disposable d) {
+    unloadSupport.scheduleDispose(d);
+  }
+
+  public static int setInterval(JavaScriptObject func, int time) {
+    return unloadSupport.setInterval(func, time);
+  }
+
+  public static int setTimeout(JavaScriptObject func, int time) {
+    return unloadSupport.setTimeout(func, time);
+  }
+
+  public static void unloadModule() {
+    if (unloadSupport.isUnloadSupported()) {
+      moduleUnloaded = true;
+      unloadSupport.disposeAll();
+    }
+  }
+
   private static native Object apply(Object jsFunction, Object thisObj,
       Object args) /*-{
     if (@com.google.gwt.core.client.GWT::isScript()()) {
@@ -254,6 +302,10 @@ private static boolean enter() {
    */
   private static Object entry0(Object jsFunction, Object thisObj,
       Object arguments) throws Throwable {
+    // if module is unloaded, don't run anything
+    if (unloadSupport.isUnloadSupported() && Impl.isModuleUnloaded()) {
+      return null;
+    }
     boolean initialEntry = enter();
 
     try {
@@ -324,7 +376,7 @@ private static native Object undefined() /*-{
   }-*/;
 
   private static native void watchdogEntryDepthCancel(int timerId) /*-{
-    $wnd.clearTimeout(timerId);
+    @com.google.gwt.core.client.impl.Impl::clearTimeout(I)(timerId);
   }-*/;
 
   private static void watchdogEntryDepthRun() {
@@ -337,7 +389,7 @@ private static void watchdogEntryDepthRun() {
   }
 
   private static native int watchdogEntryDepthSchedule() /*-{
-    return $wnd.setTimeout(function() {
+    return @com.google.gwt.core.client.impl.Impl::setTimeout(Lcom/google/gwt/core/client/JavaScriptObject;I)(function() {
       @com.google.gwt.core.client.impl.Impl::watchdogEntryDepthRun()();
     }, 10);
   }-*/;

user/src/com/google/gwt/core/client/impl/SchedulerImpl.java

@@ -189,15 +189,15 @@ private static JsArray<Task> runScheduledTasks(JsArray<Task> tasks,
 
   private static native void scheduleFixedDelayImpl(RepeatingCommand cmd,
       int delayMs) /*-{
-    $wnd.setTimeout(function() {
+    @com.google.gwt.core.client.impl.Impl::setTimeout(Lcom/google/gwt/core/client/JavaScriptObject;I)(function() {
       // $entry takes care of uncaught exception handling
       var ret = $entry(@com.google.gwt.core.client.impl.SchedulerImpl::execute(Lcom/google/gwt/core/client/Scheduler$RepeatingCommand;))(cmd);
       if ([email protected]::isScript()()) {
         // Unwrap from Development Mode
         ret = ret == true;
       }
       if (ret) {
-        $wnd.setTimeout(arguments.callee, delayMs);
+        @com.google.gwt.core.client.impl.Impl::setTimeout(Lcom/google/gwt/core/client/JavaScriptObject;I)(arguments.callee, delayMs);
       }
     }, delayMs);
   }-*/;
@@ -213,10 +213,10 @@ private static native void scheduleFixedPeriodImpl(RepeatingCommand cmd,
       }
       if (!ret) {
         // Either canceled or threw an exception
-        $wnd.clearInterval(arguments.callee.token);
+        @com.google.gwt.core.client.impl.Impl::clearInterval(I)(arguments.callee.token);
       }
     };
-    fn.token = $wnd.setInterval(fn, delayMs);
+    fn.token = @com.google.gwt.core.client.impl.Impl::setInterval(Lcom/google/gwt/core/client/JavaScriptObject;I)(fn, delayMs);
   }-*/;
 
   /**

user/src/com/google/gwt/core/client/impl/UnloadSupport.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.core.client.impl;
+
+import com.google.gwt.core.client.JavaScriptObject;
+
+/**
+ * Rebound class to enable/disable support for {@link com.google.gwt.core.client.GWT#unloadModule()}
+ */
+public class UnloadSupport {
+
+  static native void clearInterval0(int timerId) /*-{
+    window.clearInterval(timerId);
+  }-*/;
+
+  static native void clearTimeout0(int timerId) /*-{
+    window.clearTimeout(timerId);
+  }-*/;
+
+  static native int setInterval0(JavaScriptObject func, int time) /*-{
+    var timerId = window.setInterval(function () {
+      func();
+    }, time);
+    return timerId;
+  }-*/;
+
+  static native int setTimeout0(JavaScriptObject func, int time, Disposable disposeable) /*-{
+    var timerId = window.setTimeout(function () {
+      func();
+      if (disposeable != null) {
+        @com.google.gwt.core.client.impl.Impl::dispose(Lcom/google/gwt/core/client/impl/Disposable;)(disposeable);
+      }
+    }, time);
+    return timerId;
+  }-*/;
+
+  public void exportUnloadModule() {
+  }
+
+  /**
+   * Return true if {@link com.google.gwt.core.client.GWT#unloadModule()} is enabled. Default is false.
+   */
+  public boolean isUnloadSupported() {
+    return false;
+  }
+
+  void clearInterval(int timerId) {
+    clearInterval0(timerId);
+  }
+
+  void clearTimeout(int timerId) {
+    clearTimeout0(timerId);
+  }
+
+  void dispose(Disposable d) {
+    if (d != null) {
+      d.dispose();
+    }
+  }
+
+  void disposeAll() {
+  }
+
+  void scheduleDispose(Disposable d) {
+  }
+  
+
+  int setInterval(JavaScriptObject func, int time) {
+    return setInterval0(func, time);
+  }
+
+  int setTimeout(JavaScriptObject func, int time) {
+    return setTimeout0(func, time, null);
+  }
+}