JBR-1517 Update font layout speedup code to match the variant submitted to OpenJDK (JDK-8220231)

apply corresponding change from OpenJDK 13

Author: JB-Dmitry

src/java.desktop/macosx/classes/sun/font/CFont.java

@@ -76,18 +76,11 @@ GeneralPath getGlyphVectorOutline(long pScalerContext,
        throw new InternalError("Not implemented");
     }
 
-    @Override
-    protected long getLayoutTableCache() {
-        return getLayoutTableCacheNative(getNativeFontPtr());
-    }
-
     @Override
     protected byte[] getTableBytes(int tag) {
         return getTableBytesNative(getNativeFontPtr(), tag);
     }
 
-    private native synchronized long getLayoutTableCacheNative(long nativeFontPtr);
-
     private native byte[] getTableBytesNative(long nativeFontPtr, int tag);
 
     private static native long createNativeFont(final String nativeFontName,

src/java.desktop/macosx/native/libawt_lwawt/font/AWTFont.h

@@ -26,16 +26,13 @@
 #import <Cocoa/Cocoa.h>
 #import <JavaRuntimeSupport/JavaRuntimeSupport.h>
 
-#import "fontscalerdefs.h"
-
 #define MAX_STACK_ALLOC_GLYPH_BUFFER_SIZE 256
 
 @interface AWTFont : NSObject {
 @public
     NSFont    *fFont;
     CGFontRef  fNativeCGFont;
     BOOL       fIsFakeItalic;
-    TTLayoutTableCache* layoutTableCache;
 }
 
 + (AWTFont *) awtFontForName:(NSString *)name

src/java.desktop/macosx/native/libawt_lwawt/font/AWTFont.m

@@ -43,44 +43,17 @@ - (id) initWithFont:(NSFont *)font {
     if (self) {
         fFont = [font retain];
         fNativeCGFont = CTFontCopyGraphicsFont((CTFontRef)font, NULL);
-        layoutTableCache = NULL;
     }
     return self;
 }
 
-static TTLayoutTableCache* newCFontLayoutTableCache() {
-  TTLayoutTableCache* ltc = calloc(1, sizeof(TTLayoutTableCache));
-  if (ltc) {
-    int i;
-    for(i=0;i<LAYOUTCACHE_ENTRIES;i++) {
-      ltc->entries[i].len = -1;
-    }
-  }
-  return ltc;
-}
-
-static void freeCFontLayoutTableCache(TTLayoutTableCache* ltc) {
-  if (ltc) {
-    int i;
-    for(i=0;i<LAYOUTCACHE_ENTRIES;i++) {
-      if(ltc->entries[i].ptr) free (ltc->entries[i].ptr);
-    }
-    if (ltc->kernPairs) free(ltc->kernPairs);
-    free(ltc);
-  }
-}
-
 - (void) dealloc {
     [fFont release];
     fFont = nil;
 
     if (fNativeCGFont) {
         CGFontRelease(fNativeCGFont);
     fNativeCGFont = NULL;
-    if (layoutTableCache != NULL) {
-        freeCFontLayoutTableCache(layoutTableCache);
-        layoutTableCache = NULL;
-    }
     }
 
     [super dealloc];
@@ -91,10 +64,6 @@ - (void) finalize {
         CGFontRelease(fNativeCGFont);
     fNativeCGFont = NULL;
     }
-    if (layoutTableCache != NULL) {
-        freeCFontLayoutTableCache(layoutTableCache);
-        layoutTableCache = NULL;
-    }
     [super finalize];
 }
 
@@ -476,23 +445,6 @@ static JNF_MEMBER_CACHE(jm_registerFont, jc_CFontManager,
     return (jlong)(awtFont->fNativeCGFont);
 }
 
-/*
- * Class:     sun_font_CFont
- * Method:    getLayoutTableCacheNative
- * Signature: (J)J
- */
-JNIEXPORT jlong JNICALL
-Java_sun_font_CFont_getLayoutTableCacheNative
-    (JNIEnv *env, jclass clazz,
-     jlong awtFontPtr)
-{
-    AWTFont *awtFont = (AWTFont *)jlong_to_ptr(awtFontPtr);
-    if (awtFont->layoutTableCache == NULL) {
-        awtFont->layoutTableCache = newCFontLayoutTableCache();
-    }
-    return (jlong)(awtFont->layoutTableCache);
-}
-
 /*
  * Class:     sun_font_CFont
  * Method:    getTableBytesNative

src/java.desktop/share/classes/sun/font/Font2D.java

@@ -467,13 +467,6 @@ protected byte[] getTableBytes(int tag) {
         return null;
     }
 
-    /* implemented for fonts backed by an sfnt that has
-     * OpenType or AAT layout tables.
-     */
-    protected long getLayoutTableCache() {
-        return 0L;
-    }
-
     /* Used only on OS X.
      */
     protected long getPlatformNativeFontPtr() {

src/java.desktop/share/classes/sun/font/FontScaler.java

@@ -181,25 +181,6 @@ public void dispose() {}
     abstract int getMissingGlyphCode() throws FontScalerException;
     abstract int getGlyphCode(char charCode) throws FontScalerException;
 
-    /* This method returns table cache used by native layout engine.
-     * This cache is essentially just small collection of
-     * pointers to various truetype tables. See definition of TTLayoutTableCache
-     * in the fontscalerdefs.h for more details.
-     *
-     * Note that tables themselves have same format as defined in the truetype
-     * specification, i.e. font scaler do not need to perform any preprocessing.
-     *
-     * Probably it is better to have API to request pointers to each table
-     * separately instead of requesting pointer to some native structure.
-     * (then there is not need to share its definition by different
-     * implementations of scaler).
-     * However, this means multiple JNI calls and potential impact on performance.
-     *
-     * Note: return value 0 is legal.
-     *   This means tables are not available (e.g. type1 font).
-     */
-    abstract long getLayoutTableCache() throws FontScalerException;
-
     /* Used by the OpenType engine for mark positioning. */
     abstract Point2D.Float getGlyphPoint(long pScalerContext,
                                 int glyphCode, int ptNumber)

src/java.desktop/share/classes/sun/font/FreetypeFontScaler.java

@@ -178,10 +178,6 @@ synchronized GeneralPath getGlyphVectorOutline(
             .getNullScaler().getGlyphVectorOutline(0L, glyphs, numGlyphs, x, y);
     }
 
-    synchronized long getLayoutTableCache() throws FontScalerException {
-        return getLayoutTableCacheNative(nativeScaler);
-    }
-
     public synchronized void dispose() {
         if (nativeScaler != 0L) {
             disposeNativeScaler(font.get(), nativeScaler);
@@ -258,8 +254,6 @@ private native GeneralPath getGlyphVectorOutlineNative(Font2D font,
     native Point2D.Float getGlyphPointNative(Font2D font,
             long pScalerContext, long pScaler, int glyphCode, int ptNumber);
 
-    private native long getLayoutTableCacheNative(long pScaler);
-
     private native void disposeNativeScaler(Font2D font2D, long pScaler);
 
     private native int getGlyphCodeNative(Font2D font, long pScaler, char charCode);

src/java.desktop/share/classes/sun/font/NullFontScaler.java

@@ -64,8 +64,6 @@ GeneralPath getGlyphVectorOutline(long pScalerContext, int[] glyphs,
         return new GeneralPath();
     }
 
-    long getLayoutTableCache() {return 0L;}
-
     long createScalerContext(double[] matrix, int aa,
         int fm, float boldness, float italic, boolean disableHinting) {
         return getNullScalerContext();

src/java.desktop/share/classes/sun/font/SunLayoutEngine.java

@@ -31,10 +31,13 @@
 package sun.font;
 
 import sun.font.GlyphLayout.*;
+import sun.java2d.Disposer;
+import sun.java2d.DisposerRecord;
+
 import java.awt.geom.Point2D;
 import java.lang.ref.SoftReference;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.Locale;
+import java.util.WeakHashMap;
 
 /*
  * different ways to do this
@@ -143,8 +146,10 @@ public LayoutEngine getEngine(LayoutEngineKey key) {
     }
     private SoftReference<ConcurrentHashMap<LayoutEngineKey, LayoutEngine>> cacheref =
         new SoftReference<>(null);
+    private static final WeakHashMap<Font2D, FaceRef> facePtr =
+            new WeakHashMap<>();
 
-    private boolean isAAT(Font2D font) {
+    private static boolean isAAT(Font2D font) {
        // CoreText layout code ignores fractional metrics font attribute
        // also, using CoreText layout in Harfbuzz code leads to wrong advances for emoji glyphs
        return false;
@@ -154,30 +159,67 @@ private SunLayoutEngine(LayoutEngineKey key) {
         this.key = key;
     }
 
+    private long getFacePtr(Font2D font2D) {
+        FaceRef ref;
+        synchronized (facePtr) {
+            ref = facePtr.computeIfAbsent(font2D, FaceRef::new);
+        }
+        return ref.getNativePtr();
+    }
+
     public void layout(FontStrikeDesc desc, float[] mat, float ptSize, int gmask,
                        int baseIndex, TextRecord tr, int typo_flags,
                        Point2D.Float pt, GVData data) {
         Font2D font = key.font();
         FontStrike strike = font.getStrike(desc);
-        long layoutTables = font.getLayoutTableCache();
         long pNativeFont = font.getPlatformNativeFontPtr(); // used on OSX
-        // pScaler probably not needed long term.
-        long pScaler = 0L;
-        if (font instanceof FileFont) {
-            pScaler = ((FileFont)font).getScaler().nativeScaler;
+        long pFace = getFacePtr(font);
+        if (pFace != 0) {
+            shape(font, strike, ptSize, mat, pNativeFont,
+                    pFace, isAAT(font),
+                    tr.text, data, key.script(),
+                    tr.start, tr.limit, baseIndex, pt,
+                    typo_flags, gmask);
         }
-        shape(font, strike, ptSize, mat, pScaler, pNativeFont,
-              layoutTables, isAAT(font),
-              tr.text, data, key.script(),
-              tr.start, tr.limit, baseIndex, pt,
-              typo_flags, gmask);
     }
 
     /* Native method to invoke harfbuzz layout engine */
     private static native boolean
         shape(Font2D font, FontStrike strike, float ptSize, float[] mat,
-              long pscaler, long pNativeFont, long layoutTables, boolean aat,
+              long pNativeFont, long pFace, boolean aat,
               char[] chars, GVData data,
               int script, int offset, int limit,
               int baseIndex, Point2D.Float pt, int typo_flags, int slot);
+
+    private static native long createFace(Font2D font,
+                                          boolean aat,
+                                          long platformNativeFontPtr);
+
+    private static native void disposeFace(long facePtr);
+
+    private static class FaceRef implements DisposerRecord {
+        private Font2D font;
+        private Long facePtr;
+
+        private FaceRef(Font2D font) {
+            this.font = font;
+        }
+
+        private synchronized long getNativePtr() {
+            if (facePtr == null) {
+                facePtr = createFace(font, isAAT(font),
+                        font.getPlatformNativeFontPtr());
+                if (facePtr != 0) {
+                    Disposer.addObjectRecord(font, this);
+                }
+                font = null;
+            }
+            return facePtr;
+        }
+
+        @Override
+        public void dispose() {
+            disposeFace(facePtr);
+        }
+    }
 }

src/java.desktop/share/classes/sun/font/TrueTypeFont.java

@@ -898,15 +898,6 @@ ByteBuffer getTableBuffer(int tag) {
         }
     }
 
-    @Override
-    protected long getLayoutTableCache() {
-        try {
-          return getScaler().getLayoutTableCache();
-        } catch(FontScalerException fe) {
-            return 0L;
-        }
-    }
-
     @Override
     protected byte[] getTableBytes(int tag) {
         ByteBuffer buffer = getTableBuffer(tag);

src/java.desktop/share/native/common/font/fontscalerdefs.h

@@ -88,32 +88,8 @@ typedef struct GlyphInfo {
    */
 #define INVISIBLE_GLYPHS 0xfffe
 
-#define GSUB_TAG 0x47535542 /* 'GSUB' */
-#define GPOS_TAG 0x47504F53 /* 'GPOS' */
-#define GDEF_TAG 0x47444546 /* 'GDEF' */
-#define HEAD_TAG 0x68656164 /* 'head' */
-#define MORT_TAG 0x6D6F7274 /* 'mort' */
-#define MORX_TAG 0x6D6F7278 /* 'morx' */
-#define KERN_TAG 0x6B65726E /* 'kern' */
-
-typedef struct TTLayoutTableCacheEntry {
-  const void* ptr;
-  int   len;
-  int   tag;
-} TTLayoutTableCacheEntry;
-
-#define LAYOUTCACHE_ENTRIES 7
-
-typedef struct TTLayoutTableCache {
-  TTLayoutTableCacheEntry entries[LAYOUTCACHE_ENTRIES];
-  void* kernPairs;
-} TTLayoutTableCache;
-
 #include "sunfontids.h"
 
-JNIEXPORT extern TTLayoutTableCache* newLayoutTableCache();
-JNIEXPORT extern void freeLayoutTableCache(TTLayoutTableCache* ltc);
-
 /* If font is malformed then scaler context created by particular scaler
  * will be replaced by null scaler context.
  * Note that this context is not compatible with structure of the context