Fix OSX CALayer Bug 690 and Bug 691: Occasional Freeze on CVDisplayLinkStop; Layers and native GL-Context are _not_ Released ; Java Side wait for Main-Thread

- Fix Bug 690: Occasional Freeze on CVDisplayLinkStop
  - NSOpenGLLayer.disableAnimation() shall not claim the renderLock mutex,
    since the CVDisplayLink callback could be waiting for the lock.
    This waiting callback could freeze the call to CVDisplayLinkStop.

- Fix Bug 691: Layers and native GL-Context are _not_ Released
  - Following proper release cycle:

    Context unrealized:
      - JAWTWindow.detachSurfaceLayer() -> OSXUtil.RemoveCASublayer(..)
      - CGL.releaseNSOpenGLLayer(..)

    JAWTWindow.destroy()
      - MacOSXJAWTWindow.UnsetJAWTRootSurfaceLayer(..)
      - OSXUtil.DestroyCALayer(..)

  - 'Magic' CALayer release calls (w/o manual retain beforehand) at:
     - OSXUtil.RemoveCASublayer(..): [subLayer release]
     - MacOSXJAWTWindow.UnsetJAWTRootSurfaceLayer(..): [rootLayer release]
     - OSXUtil.DestroyCALayer(..): [rootLayer release]

  - 'Magic' NSOpenGLLayer's NSOpenGLContext dealloc:
     - [NSOpenGLContext clearDrawable]
     - CGLDestroyContext( [NSOpenGLContext CGLContextObj] )

- Java Side wait for Main-Thread
  - Waiting for the delegated Main-Thread on the Java side eases debugging
    and won't block the Main-Thread in native code.

  - Utilizing this for all CALayer calls

Test case: TestGLCanvasAddRemove01SwingAWT

4 files changed, 126 insertions, 30 deletions

diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/awt/JAWTWindow.java b/src/nativewindow/classes/com/jogamp/nativewindow/awt/JAWTWindow.java
index 8527a0200..007a917a6 100644
--- a/src/nativewindow/classes/com/jogamp/nativewindow/awt/JAWTWindow.java
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/awt/JAWTWindow.java
@@ -205,7 +205,7 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
       }
       try {
           if(DEBUG) {
-            System.err.println("JAWTWindow.attachSurfaceHandle(): 0x"+Long.toHexString(layerHandle) + ", bounds "+bounds);
+            System.err.println("JAWTWindow.attachSurfaceHandle(): "+toHexString(layerHandle) + ", bounds "+bounds);
           }
           attachSurfaceLayerImpl(layerHandle);
           offscreenSurfaceLayer = layerHandle;
@@ -229,7 +229,7 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
       }
       try {
           if(DEBUG) {
-            System.err.println("JAWTWindow.detachSurfaceHandle(): 0x"+Long.toHexString(offscreenSurfaceLayer));
+            System.err.println("JAWTWindow.detachSurfaceHandle(): osh "+toHexString(offscreenSurfaceLayer));
           }
           detachSurfaceLayerImpl(offscreenSurfaceLayer);
           offscreenSurfaceLayer = 0;
@@ -341,7 +341,7 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
                     if(LOCK_SUCCESS == res && drawable_old != drawable) {
                         res = LOCK_SURFACE_CHANGED;
                         if(DEBUG) {
-                            System.err.println("JAWTWindow: surface change 0x"+Long.toHexString(drawable_old)+" -> 0x"+Long.toHexString(drawable));
+                            System.err.println("JAWTWindow: surface change "+toHexString(drawable_old)+" -> "+toHexString(drawable));
                             // Thread.dumpStack();
                         }
                     }
@@ -549,8 +549,8 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
     StringBuilder sb = new StringBuilder();
 
     sb.append("JAWT-Window["+
-                "windowHandle 0x"+Long.toHexString(getWindowHandle())+
-                ", surfaceHandle 0x"+Long.toHexString(getSurfaceHandle())+
+                "windowHandle "+toHexString(getWindowHandle())+
+                ", surfaceHandle "+toHexString(getSurfaceHandle())+
                 ", bounds "+bounds+", insets "+insets+
                 ", shallUseOffscreenLayer "+shallUseOffscreenLayer+", isOffscreenLayerSurface "+isOffscreenLayerSurface);
     if(null!=component) {
@@ -566,4 +566,8 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
 
     return sb.toString();
   }
+  
+  protected final String toHexString(long l) {
+      return "0x"+Long.toHexString(l);
+  }
 }
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/swt/SWTAccessor.java b/src/nativewindow/classes/com/jogamp/nativewindow/swt/SWTAccessor.java
index 2b49f6745..5479f2495 100644
--- a/src/nativewindow/classes/com/jogamp/nativewindow/swt/SWTAccessor.java
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/swt/SWTAccessor.java
@@ -38,7 +38,6 @@ import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.widgets.Control;
 
 import javax.media.nativewindow.AbstractGraphicsScreen;
-import javax.media.nativewindow.DefaultGraphicsScreen;
 import javax.media.nativewindow.NativeWindowException;
 import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.nativewindow.NativeWindowFactory;
@@ -49,7 +48,6 @@ import com.jogamp.common.util.VersionNumber;
 import com.jogamp.nativewindow.macosx.MacOSXGraphicsDevice;
 import com.jogamp.nativewindow.windows.WindowsGraphicsDevice;
 import com.jogamp.nativewindow.x11.X11GraphicsDevice;
-import com.jogamp.nativewindow.x11.X11GraphicsScreen;
 
 import jogamp.nativewindow.macosx.OSXUtil;
 import jogamp.nativewindow.x11.X11Lib;
diff --git a/src/nativewindow/classes/jogamp/nativewindow/jawt/macosx/MacOSXJAWTWindow.java b/src/nativewindow/classes/jogamp/nativewindow/jawt/macosx/MacOSXJAWTWindow.java
index 9e270d403..9b06cce1a 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/jawt/macosx/MacOSXJAWTWindow.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/jawt/macosx/MacOSXJAWTWindow.java
@@ -51,6 +51,7 @@ import javax.media.nativewindow.NativeWindowException;
 import javax.media.nativewindow.MutableSurface;
 import javax.media.nativewindow.util.Point;
 
+import com.jogamp.common.util.Function;
 import com.jogamp.nativewindow.awt.JAWTWindow;
 
 import jogamp.nativewindow.jawt.JAWT;
@@ -70,11 +71,40 @@ public class MacOSXJAWTWindow extends JAWTWindow implements MutableSurface {
   }
 
   protected void invalidateNative() {
+      if(DEBUG) {
+          System.err.println("MacOSXJAWTWindow.invalidateNative(): osh-enabled "+isOffscreenLayerSurfaceEnabled()+
+                             ", osh-set "+offscreenSurfaceHandleSet+
+                             ", osh "+toHexString(offscreenSurfaceHandle)+
+                             ", rsh "+toHexString(rootSurfaceLayerHandle)+
+                             ", wh "+toHexString(windowHandle));
+      }
       offscreenSurfaceHandle=0;
       offscreenSurfaceHandleSet=false;
-      if(isOffscreenLayerSurfaceEnabled()) {
+      if( isOffscreenLayerSurfaceEnabled() ) {
           if(0 != rootSurfaceLayerHandle) {
+              final JAWT jawt = getJAWT();
+              if( null != jawt ) {
+                  final JAWT_DrawingSurface ds = jawt.GetDrawingSurface(component);
+                  if (ds != null) {
+                      if ( 0 == ( ds.Lock() & JAWTFactory.JAWT_LOCK_ERROR ) ) {
+                          JAWT_DrawingSurfaceInfo dsi = null;
+                          try {
+                              dsi = ds.GetDrawingSurfaceInfo();
+                              if(! UnsetJAWTRootSurfaceLayer(dsi.getBuffer(), rootSurfaceLayerHandle)) {
+                                  System.err.println("Error clearing JAWT rootSurfaceLayerHandle "+toHexString(rootSurfaceLayerHandle));
+                              }
+                          } finally {
+                              if ( null != dsi ) {
+                                  ds.FreeDrawingSurfaceInfo(dsi);
+                              }
+                              ds.Unlock();
+                          }
+                      }
+                      jawt.FreeDrawingSurface(ds);
+                  }
+              }
               OSXUtil.DestroyCALayer(rootSurfaceLayerHandle);
+              
               rootSurfaceLayerHandle = 0;
           }
           if(0 != windowHandle) {
@@ -107,7 +137,7 @@ public class MacOSXJAWTWindow extends JAWTWindow implements MutableSurface {
           throw new java.lang.UnsupportedOperationException("Not using CALAYER");
       }
       if(DEBUG) {
-        System.err.println("MacOSXJAWTWindow.setSurfaceHandle(): 0x"+Long.toHexString(surfaceHandle));
+        System.err.println("MacOSXJAWTWindow.setSurfaceHandle(): "+toHexString(surfaceHandle));
       }
       this.offscreenSurfaceHandle = surfaceHandle;
       this.offscreenSurfaceHandleSet = true;
@@ -117,6 +147,7 @@ public class MacOSXJAWTWindow extends JAWTWindow implements MutableSurface {
        // use offscreen if supported and [ applet or requested ]
       return JAWTUtil.getJAWT(getShallUseOffscreenLayer() || isApplet());
   }
+  
   protected int lockSurfaceImpl() throws NativeWindowException {
     int ret = NativeWindow.LOCK_SURFACE_NOT_READY;
     ds = getJAWT().GetDrawingSurface(component);
@@ -189,7 +220,7 @@ public class MacOSXJAWTWindow extends JAWTWindow implements MutableSurface {
             } else {
                 drawable = OSXUtil.GetNSView(windowHandle);
                 if(0 == drawable) {
-                  errMsg = "Null NSView of NSWindow 0x"+Long.toHexString(windowHandle);
+                  errMsg = "Null NSView of NSWindow "+toHexString(windowHandle);
                 }
             }
             if(null == errMsg) {
@@ -204,8 +235,8 @@ public class MacOSXJAWTWindow extends JAWTWindow implements MutableSurface {
                 rootSurfaceLayerHandle = OSXUtil.CreateCALayer(bounds.getX(), bounds.getY(), bounds.getWidth(), bounds.getHeight());
                 if(0 == rootSurfaceLayerHandle) {
                   errMsg = "Could not create root CALayer";                
-                } else if(!SetJAWTRootSurfaceLayer0(dsi.getBuffer(), rootSurfaceLayerHandle)) {
-                  errMsg = "Could not set JAWT rootSurfaceLayerHandle 0x"+Long.toHexString(rootSurfaceLayerHandle);
+                } else if(!SetJAWTRootSurfaceLayer(dsi.getBuffer(), rootSurfaceLayerHandle)) {
+                  errMsg = "Could not set JAWT rootSurfaceLayerHandle "+toHexString(rootSurfaceLayerHandle);
                 }
             }
         }
@@ -265,9 +296,23 @@ public class MacOSXJAWTWindow extends JAWTWindow implements MutableSurface {
       return getLocationOnScreenNonBlocking(storage, component);     
   }  
   protected Point getLocationOnScreenNativeImpl(final int x0, final int y0) { return null; }
+  
+  private static boolean SetJAWTRootSurfaceLayer(final Buffer jawtDrawingSurfaceInfoBuffer, final long caLayer) {
+      return OSXUtil.RunOnMainThread(true, new Function<Boolean, Object>() {
+       public Boolean eval(Object... args) {
+           return Boolean.valueOf( SetJAWTRootSurfaceLayer0(jawtDrawingSurfaceInfoBuffer, caLayer) );
+       } } ).booleanValue();
+  }
+
+  private static boolean UnsetJAWTRootSurfaceLayer(final Buffer jawtDrawingSurfaceInfoBuffer, final long caLayer) {
+      return OSXUtil.RunOnMainThread(true, new Function<Boolean, Object>() {
+       public Boolean eval(Object... args) {
+           return Boolean.valueOf( UnsetJAWTRootSurfaceLayer0(jawtDrawingSurfaceInfoBuffer, caLayer) );
+       } } ).booleanValue();      
+  }
 
   private static native boolean SetJAWTRootSurfaceLayer0(Buffer jawtDrawingSurfaceInfoBuffer, long caLayer);
-  // private static native boolean UnsetJAWTRootSurfaceLayer0(Buffer jawtDrawingSurfaceInfoBuffer, long caLayer);
+  private static native boolean UnsetJAWTRootSurfaceLayer0(Buffer jawtDrawingSurfaceInfoBuffer, long caLayer);
   
   // Variables for lockSurface/unlockSurface
   private JAWT_DrawingSurface ds;
diff --git a/src/nativewindow/classes/jogamp/nativewindow/macosx/OSXUtil.java b/src/nativewindow/classes/jogamp/nativewindow/macosx/OSXUtil.java
index f06f97064..2e133c22f 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/macosx/OSXUtil.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/macosx/OSXUtil.java
@@ -32,6 +32,8 @@ import javax.media.nativewindow.NativeWindowFactory;
 import javax.media.nativewindow.util.Insets;
 import javax.media.nativewindow.util.Point;
 
+import com.jogamp.common.util.Function;
+import com.jogamp.common.util.FunctionTask;
 import com.jogamp.common.util.RunnableTask;
 
 import jogamp.nativewindow.Debug;
@@ -137,23 +139,33 @@ public class OSXUtil implements ToolkitProperties {
     public static long CreateCALayer(int x, int y, int width, int height) {
         return CreateCALayer0(x, y, width, height);
     }
-    public static void AddCASublayer(long rootCALayer, long subCALayer) {
+    public static void AddCASublayer(final long rootCALayer, final long subCALayer) {
         if(0==rootCALayer || 0==subCALayer) {
             throw new IllegalArgumentException("rootCALayer 0x"+Long.toHexString(rootCALayer)+", subCALayer 0x"+Long.toHexString(subCALayer));
         }
-        AddCASublayer0(rootCALayer, subCALayer);
+        RunOnMainThread(true, new Runnable() {
+           public void run() {
+               AddCASublayer0(rootCALayer, subCALayer);               
+           }
+        });
     }
-    public static void RemoveCASublayer(long rootCALayer, long subCALayer) {
+    public static void RemoveCASublayer(final long rootCALayer, final long subCALayer) {
         if(0==rootCALayer || 0==subCALayer) {
             throw new IllegalArgumentException("rootCALayer 0x"+Long.toHexString(rootCALayer)+", subCALayer 0x"+Long.toHexString(subCALayer));
         }
-        RemoveCASublayer0(rootCALayer, subCALayer);
+        RunOnMainThread(true, new Runnable() {
+           public void run() {
+               RemoveCASublayer0(rootCALayer, subCALayer);
+           } } );
     }
-    public static void DestroyCALayer(long caLayer) {
+    public static void DestroyCALayer(final long caLayer) {
         if(0==caLayer) {
             throw new IllegalArgumentException("caLayer 0x"+Long.toHexString(caLayer));
         }
-        DestroyCALayer0(caLayer);    
+        RunOnMainThread(true, new Runnable() {
+           public void run() {        
+               DestroyCALayer0(caLayer);
+           } } );
     }
     
     /**
@@ -169,14 +181,14 @@ public class OSXUtil implements ToolkitProperties {
         if( IsMainThread0() ) {
             runnable.run(); // don't leave the JVM
         } else {
-            if( waitUntilDone ) {
-                // Utilize Java side lock/wait and simply pass the Runnable async to OSX main thread,
-                // otherwise we may freeze the OSX main thread.            
-                Throwable throwable = null;
-                final Object sync = new Object();
-                final RunnableTask rt = new RunnableTask( runnable, sync, true ); 
-                synchronized(sync) {
-                    RunOnMainThread0(rt);
+            // Utilize Java side lock/wait and simply pass the Runnable async to OSX main thread,
+            // otherwise we may freeze the OSX main thread.            
+            Throwable throwable = null;
+            final Object sync = new Object();
+            final RunnableTask rt = new RunnableTask( runnable, waitUntilDone ? sync : null, true ); 
+            synchronized(sync) {
+                RunOnMainThread0(rt);
+                if( waitUntilDone ) {
                     try {
                         sync.wait();
                     } catch (InterruptedException ie) {
@@ -188,10 +200,47 @@ public class OSXUtil implements ToolkitProperties {
                     if(null!=throwable) {
                         throw new RuntimeException(throwable);
                     }
-                }                
-            } else {
-                RunOnMainThread0(runnable);
+                }
+            }
+        }
+    }
+    
+    /**
+     * Run on OSX UI main thread.
+     * <p> 
+     * 'waitUntilDone' is implemented on Java site via lock/wait on {@link FunctionTask} to not freeze OSX main thread.
+     * </p>
+     * 
+     * @param waitUntilDone
+     * @param func
+     */
+    public static <R,A> R RunOnMainThread(boolean waitUntilDone, Function<R,A> func, A... args) {
+        if( IsMainThread0() ) {
+            return func.eval(args); // don't leave the JVM
+        } else {
+            // Utilize Java side lock/wait and simply pass the Runnable async to OSX main thread,
+            // otherwise we may freeze the OSX main thread.            
+            Throwable throwable = null;
+            final Object sync = new Object();
+            final FunctionTask<R,A> rt = new FunctionTask<R,A>( func, waitUntilDone ? sync : null, true ); 
+            synchronized(sync) {
+                rt.setArgs(args);
+                RunOnMainThread0(rt);
+                if( waitUntilDone ) {
+                    try {
+                        sync.wait();
+                    } catch (InterruptedException ie) {
+                        throwable = ie;
+                    }
+                    if(null==throwable) {
+                        throwable = rt.getThrowable();
+                    }
+                    if(null!=throwable) {
+                        throw new RuntimeException(throwable);
+                    }
+                }
             }
+            return rt.getResult();
         }
     }