OSX/CALayer: OSX/CALayer Threading Part3 - Run CALayer ops in a streaming design on main-thread w/o [infinitive] blocking

History:
  Part1   commit 896e8b021b39e9415040a57a1d540d7d24b02db1 (Run CALayer Ops on current thread to avoid blocking)
  Part2   commit 28c6472335b924080d638b33a28f8f4eedb459b1 (Run CALayer Ops on main-thread w/o blocking)

Dependency:
  GlueGen commit 4becdfa125b07ff969d6540e1112735b53cd15eb (Fix RecursiveLockImpl* Timeout corner case)

Part2 misses essential locking of the OpenGL context (and it's surface upfront) while creating the
NSOpenGLLayer instance. The latter instantiates a OpenGL context shared w/ JOGL's, hence it cannot be locked.

Encapsulating NSOpenGLLayer creation/attachment and it's detachment/release in sub-classes
AttachNSOpenGLLayer and DetachNSOpenGLLayer, where instances will be streamed on main-thread.

Both tasks are triggered at associateDrawable(boolean bound).

The mentioned GL context locking requires disturbs the 'streaming' design considerably in AttachNSOpenGLLayer.
It is solved by attempt to acquire the recursive lock of the surface and the context via 'tryLock(maxwait)'
w/ screen-vSync-period/2. If the locks could not be acquired completly, the AttachNSOpenGLLayer instance
will be re-queued to the main-thread for later execution.

Before DetachNSOpenGLLayer is being streamed, it is validated whether AttachNSOpenGLLayer did run.
A recursive situation does happen w/ resizing an offscreen pbuffer drawable! Hence extra care is being taken.

1 files changed, 37 insertions, 36 deletions

diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/awt/JAWTWindow.java b/src/nativewindow/classes/com/jogamp/nativewindow/awt/JAWTWindow.java
index 15a0f550f..16d4a07ef 100644
--- a/src/nativewindow/classes/com/jogamp/nativewindow/awt/JAWTWindow.java
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/awt/JAWTWindow.java
@@ -85,7 +85,7 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
   protected long drawable;
   protected Rectangle bounds;
   protected Insets insets;
-  private long offscreenSurfaceLayer;
+  private volatile long offscreenSurfaceLayer;
 
   private long drawable_old;
 
@@ -135,12 +135,12 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
 
   protected synchronized void invalidate() {
     if(DEBUG) {
-        System.err.println("JAWTWindow.invalidate()");
+        System.err.println("JAWTWindow.invalidate() - "+Thread.currentThread().getName());
+        if( isSurfaceLayerAttached() ) {
+            System.err.println("OffscreenSurfaceLayer still attached: 0x"+Long.toHexString(offscreenSurfaceLayer));        
+        }
         // Thread.dumpStack();
     }
-    if( isSurfaceLayerAttached() ) {
-        detachSurfaceLayer();
-    }
     invalidateNative();
     jawt = null;
     isOffscreenLayerSurface = false;
@@ -227,21 +227,16 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
       if( !isOffscreenLayerSurfaceEnabled() ) {
           throw new NativeWindowException("Not an offscreen layer surface");
       }
-      int lockRes = lockSurface();
-      if (NativeSurface.LOCK_SURFACE_NOT_READY >= lockRes) {
-          throw new NativeWindowException("Could not lock (offscreen layer): "+this);
-      }
-      try {
-          if(DEBUG) {
-            System.err.println("JAWTWindow.attachSurfaceHandle: "+toHexString(layerHandle) + ", bounds "+bounds);
-          }
-          attachSurfaceLayerImpl(layerHandle);
-          offscreenSurfaceLayer = layerHandle;
-      } finally {
-          unlockSurface();
+      if(DEBUG) {
+        System.err.println("JAWTWindow.attachSurfaceHandle: "+toHexString(layerHandle) + ", bounds "+bounds);
       }
+      attachSurfaceLayerImpl(layerHandle);
+      offscreenSurfaceLayer = layerHandle;
+      layoutSurfaceLayerImpl(layerHandle, getWidth(), getHeight());
+  }
+  protected void attachSurfaceLayerImpl(final long layerHandle) {
+      throw new UnsupportedOperationException("offscreen layer not supported");
   }
-  protected abstract void attachSurfaceLayerImpl(final long layerHandle);
 
   /**
    * Layout the offscreen layer according to the implementing class's constraints.
@@ -256,38 +251,39 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
    * @see #isOffscreenLayerSurfaceEnabled()
    * @throws NativeWindowException if {@link #isOffscreenLayerSurfaceEnabled()} == false
    */
-  protected void layoutSurfaceLayerImpl() {}
+  protected void layoutSurfaceLayerImpl(long layerHandle, int width, int height) {}
   
   private final void layoutSurfaceLayerIfEnabled() throws NativeWindowException {
       if( isOffscreenLayerSurfaceEnabled() && 0 != offscreenSurfaceLayer ) {
-          layoutSurfaceLayerImpl();
+          layoutSurfaceLayerImpl(offscreenSurfaceLayer, getWidth(), getHeight());
       }
   }
   
   
   @Override
   public final void detachSurfaceLayer() throws NativeWindowException {
-      if( !isOffscreenLayerSurfaceEnabled() ) {
-          throw new java.lang.UnsupportedOperationException("Not an offscreen layer surface");
-      }
       if( 0 == offscreenSurfaceLayer) {
           throw new NativeWindowException("No offscreen layer attached: "+this);
       }
-      int lockRes = lockSurface();
-      if (NativeSurface.LOCK_SURFACE_NOT_READY >= lockRes) {
-          throw new NativeWindowException("Could not lock (offscreen layer): "+this);
-      }
-      try {
-          if(DEBUG) {
-            System.err.println("JAWTWindow.detachSurfaceHandle(): osh "+toHexString(offscreenSurfaceLayer));
-          }
-          detachSurfaceLayerImpl(offscreenSurfaceLayer);
-          offscreenSurfaceLayer = 0;
-      } finally {
-          unlockSurface();
+      if(DEBUG) {
+        System.err.println("JAWTWindow.detachSurfaceHandle(): osh "+toHexString(offscreenSurfaceLayer));
       }
+      detachSurfaceLayerImpl(offscreenSurfaceLayer, detachSurfaceLayerNotify);
   }
-  protected abstract void detachSurfaceLayerImpl(final long layerHandle);
+  private final Runnable detachSurfaceLayerNotify = new Runnable() {
+    @Override
+    public void run() {
+        offscreenSurfaceLayer = 0;
+    }
+  };
+
+  /** 
+   * @param detachNotify Runnable to be called before native detachment
+   */
+  protected void detachSurfaceLayerImpl(final long layerHandle, final Runnable detachNotify) {
+      throw new UnsupportedOperationException("offscreen layer not supported");
+  }
+  
 
   @Override
   public final long getAttachedSurfaceLayer() {
@@ -305,6 +301,11 @@ public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface,
       getPrivateGraphicsConfiguration().setChosenCapabilities(caps);      
   }
   
+  @Override
+  public final RecursiveLock getLock() {
+      return surfaceLock;
+  }
+  
   //
   // SurfaceUpdateListener
   //