diff -r bbed9966db6e -r e496a8d8fc8a jdk/src/java.desktop/share/native/libfontmanager/HBShaper.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.desktop/share/native/libfontmanager/HBShaper.c	Mon Nov 23 09:58:44 2015 -0800
@@ -0,0 +1,313 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include <jni_util.h>
+#include <stdlib.h>
+#include "hb.h"
+#include "hb-jdk.h"
+#include "hb-ot.h"
+#ifdef MACOSX
+#include "hb-coretext.h"
+#endif
+#include "scriptMapping.h"
+
+static jclass gvdClass = 0;
+static const char* gvdClassName = "sun/font/GlyphLayout$GVData";
+static jfieldID gvdCountFID = 0;
+static jfieldID gvdFlagsFID = 0;
+static jfieldID gvdGlyphsFID = 0;
+static jfieldID gvdPositionsFID = 0;
+static jfieldID gvdIndicesFID = 0;
+static int jniInited = 0;
+
+static void getFloat(JNIEnv* env, jobject pt, jfloat *x, jfloat *y) {
+    *x = (*env)->GetFloatField(env, pt, sunFontIDs.xFID);
+    *y = (*env)->GetFloatField(env, pt, sunFontIDs.yFID);
+}
+
+static void putFloat(JNIEnv* env, jobject pt, jfloat x, jfloat y) {
+    (*env)->SetFloatField(env, pt, sunFontIDs.xFID, x);
+    (*env)->SetFloatField(env, pt, sunFontIDs.yFID, y);
+}
+
+static int init_JNI_IDs(JNIEnv *env) {
+    if (jniInited) {
+        return jniInited;
+    }
+    CHECK_NULL_RETURN(gvdClass = (*env)->FindClass(env, gvdClassName), 0);
+    CHECK_NULL_RETURN(gvdClass = (jclass)(*env)->NewGlobalRef(env, gvdClass), 0);
+    CHECK_NULL_RETURN(gvdCountFID = (*env)->GetFieldID(env, gvdClass, "_count", "I"), 0);
+    CHECK_NULL_RETURN(gvdFlagsFID = (*env)->GetFieldID(env, gvdClass, "_flags", "I"), 0);
+    CHECK_NULL_RETURN(gvdGlyphsFID = (*env)->GetFieldID(env, gvdClass, "_glyphs", "[I"), 0);
+    CHECK_NULL_RETURN(gvdPositionsFID = (*env)->GetFieldID(env, gvdClass, "_positions", "[F"), 0);
+    CHECK_NULL_RETURN(gvdIndicesFID = (*env)->GetFieldID(env, gvdClass, "_indices", "[I"), 0);
+    jniInited = 1;
+    return jniInited;
+}
+
+// gmask is the composite font slot mask
+// baseindex is to be added to the character (code point) index.
+int storeGVData(JNIEnv* env,
+               jobject gvdata, jint slot, jint baseIndex, jobject startPt,
+               int glyphCount, hb_glyph_info_t *glyphInfo,
+               hb_glyph_position_t *glyphPos, hb_direction_t direction) {
+
+    int i;
+    float x=0, y=0;
+    float startX, startY;
+    float scale = 1.0f/64.0f;
+    unsigned int* glyphs;
+    float* positions;
+
+    if (!init_JNI_IDs(env)) {
+        return 0;
+    }
+
+    int initialCount = (*env)->GetIntField(env, gvdata, gvdCountFID);
+    jarray glyphArray =
+       (jarray)(*env)->GetObjectField(env, gvdata, gvdGlyphsFID);
+    jarray posArray =
+        (jarray)(*env)->GetObjectField(env, gvdata, gvdPositionsFID);
+
+    if (glyphArray == NULL || posArray == NULL)
+    {
+        JNU_ThrowArrayIndexOutOfBoundsException(env, "");
+        return 0;
+    }
+
+    // The Java code catches the IIOBE and expands the storage
+    // and re-invokes layout. I suppose this is expected to be rare
+    // because at least in a single threaded case there should be
+    // re-use of the same container, but it is a little wasteful/distateful.
+    int glyphArrayLen = (*env)->GetArrayLength(env, glyphArray);
+    int posArrayLen = (*env)->GetArrayLength(env, posArray);
+    int maxGlyphs = glyphCount + initialCount;
+    if ((maxGlyphs >  glyphArrayLen) ||
+        (maxGlyphs * 2 + 2 >  posArrayLen))
+    {
+        JNU_ThrowArrayIndexOutOfBoundsException(env, "");
+        return 0;
+    }
+
+    getFloat(env, startPt, &startX, &startY);
+
+    glyphs =
+        (unsigned int*)(*env)->GetPrimitiveArrayCritical(env, glyphArray, NULL);
+    positions = (jfloat*)(*env)->GetPrimitiveArrayCritical(env, posArray, NULL);
+    for (i = 0; i < glyphCount; i++) {
+        int storei = i + initialCount;
+        int index = glyphInfo[i].codepoint | slot;
+        if (i<glyphCount)glyphs[storei] = (unsigned int)index;
+        positions[(storei*2)] = startX + x + glyphPos[i].x_offset * scale;
+        positions[(storei*2)+1] = startY + y - glyphPos[i].y_offset * scale;
+        x += glyphPos[i].x_advance * scale;
+        y += glyphPos[i].y_advance * scale;
+    }
+    int storeadv = initialCount+glyphCount;
+    // The final slot in the positions array is important
+    // because when the GlyphVector is created from this
+    // data it determines the overall advance of the glyphvector
+    // and this is used in positioning the next glyphvector
+    // during rendering where text is broken into runs.
+    // We also need to report it back into "pt", so layout can
+    // pass it back down for that next run in this code.
+    positions[(storeadv*2)] = startX + x;
+    positions[(storeadv*2)+1] = startY + y;
+    (*env)->ReleasePrimitiveArrayCritical(env, glyphArray, glyphs, 0);
+    (*env)->ReleasePrimitiveArrayCritical(env, posArray, positions, 0);
+    putFloat(env, startPt,positions[(storeadv*2)],positions[(storeadv*2)+1] );
+    jarray inxArray =
+        (jarray)(*env)->GetObjectField(env, gvdata, gvdIndicesFID);
+    unsigned int* indices =
+        (unsigned int*)(*env)->GetPrimitiveArrayCritical(env, inxArray, NULL);
+    int prevCluster = -1;
+    for (i = 0; i < glyphCount; i++) {
+        int cluster = glyphInfo[i].cluster;
+        if (direction == HB_DIRECTION_LTR) {
+            // I need to understand what hb does when processing a substring
+            // I expected the cluster index to be from the start of the text
+            // to process.
+            // Instead it appears to be from the start of the whole thing.
+            indices[i+initialCount] = cluster;
+        } else {
+            indices[i+initialCount] = baseIndex + glyphCount -1 -i;
+        }
+    }
+    (*env)->ReleasePrimitiveArrayCritical(env, inxArray, indices, 0);
+    (*env)->SetIntField(env, gvdata, gvdCountFID, initialCount+glyphCount);
+    return initialCount+glyphCount;
+}
+
+static float euclidianDistance(float a, float b)
+{
+    float root;
+    if (a < 0) {
+        a = -a;
+    }
+
+    if (b < 0) {
+        b = -b;
+    }
+
+    if (a == 0) {
+        return b;
+    }
+
+    if (b == 0) {
+        return a;
+    }
+
+    /* Do an initial approximation, in root */
+    root = a > b ? a + (b / 2) : b + (a / 2);
+
+    /* An unrolled Newton-Raphson iteration sequence */
+    root = (root + (a * (a / root)) + (b * (b / root)) + 1) / 2;
+    root = (root + (a * (a / root)) + (b * (b / root)) + 1) / 2;
+    root = (root + (a * (a / root)) + (b * (b / root)) + 1) / 2;
+
+    return root;
+}
+
+JDKFontInfo*
+     createJDKFontInfo(JNIEnv *env,
+                       jobject font2D,
+                       jobject fontStrike,
+                       jfloat ptSize,
+                       jlong pScaler,
+                       jlong pNativeFont,
+                       jfloatArray matrix,
+                       jboolean aat) {
+
+
+    JDKFontInfo *fi = (JDKFontInfo*)malloc(sizeof(JDKFontInfo));
+    if (!fi) {
+       return NULL;
+    }
+    fi->env = env; // this is valid only for the life of this JNI call.
+    fi->font2D = font2D;
+    fi->fontStrike = fontStrike;
+    fi->nativeFont = pNativeFont;
+    fi->aat = aat;
+    (*env)->GetFloatArrayRegion(env, matrix, 0, 4, fi->matrix);
+    fi->ptSize = ptSize;
+    fi->xPtSize = euclidianDistance(fi->matrix[0], fi->matrix[1]);
+    fi->yPtSize = euclidianDistance(fi->matrix[2], fi->matrix[3]);
+
+    return fi;
+}
+
+
+#define TYPO_RTL 0x80000000
+
+JNIEXPORT jboolean JNICALL Java_sun_font_SunLayoutEngine_shape
+    (JNIEnv *env, jclass cls,
+     jobject font2D,
+     jobject fontStrike,
+     jfloat ptSize,
+     jfloatArray matrix,
+     jlong pScaler,
+     jlong pNativeFont,
+     jboolean aat,
+     jcharArray text,
+     jobject gvdata,
+     jint script,
+     jint offset,
+     jint limit,
+     jint baseIndex,
+     jobject startPt,
+     jint flags,
+     jint slot) {
+
+     hb_buffer_t *buffer;
+     hb_font_t* hbfont;
+     jchar  *chars;
+     jsize len;
+     int glyphCount;
+     hb_glyph_info_t *glyphInfo;
+     hb_glyph_position_t *glyphPos;
+     hb_direction_t direction = HB_DIRECTION_LTR;
+     hb_feature_t *features =  NULL;
+     int featureCount = 0;
+
+     int i;
+     unsigned int buflen;
+
+     JDKFontInfo *jdkFontInfo =
+         createJDKFontInfo(env, font2D, fontStrike, ptSize,
+                           pScaler, pNativeFont, matrix, aat);
+     if (!jdkFontInfo) {
+        return JNI_FALSE;
+     }
+     jdkFontInfo->env = env; // this is valid only for the life of this JNI call.
+     jdkFontInfo->font2D = font2D;
+     jdkFontInfo->fontStrike = fontStrike;
+
+     hbfont = hb_jdk_font_create(jdkFontInfo, NULL);
+
+     buffer = hb_buffer_create();
+     hb_buffer_set_script(buffer, getHBScriptCode(script));
+     hb_buffer_set_language(buffer,
+                            hb_ot_tag_to_language(HB_OT_TAG_DEFAULT_LANGUAGE));
+     if ((flags & TYPO_RTL) != 0) {
+         direction = HB_DIRECTION_RTL;
+     }
+     hb_buffer_set_direction(buffer, direction);
+
+     chars = (*env)->GetCharArrayElements(env, text, NULL);
+     len = (*env)->GetArrayLength(env, text);
+
+     hb_buffer_add_utf16(buffer, chars, len, offset, limit-offset);
+
+     hb_shape_full(hbfont, buffer, features, featureCount, 0);
+     glyphCount = hb_buffer_get_length(buffer);
+     glyphInfo = hb_buffer_get_glyph_infos(buffer, 0);
+     glyphPos = hb_buffer_get_glyph_positions(buffer, &buflen);
+     for (i = 0; i < glyphCount; i++) {
+         int index = glyphInfo[i].codepoint;
+         int xadv = (glyphPos[i].x_advance);
+         int yadv = (glyphPos[i].y_advance);
+     }
+     // On "input" HB assigns a cluster index to each character in UTF-16.
+     // On output where a sequence of characters have been mapped to
+     // a glyph they are all mapped to the cluster index of the first character.
+     // The next cluster index will be that of the first character in the
+     // next cluster. So cluster indexes may 'skip' on output.
+     // This can also happen if there are supplementary code-points
+     // such that two UTF-16 characters are needed to make one codepoint.
+     // In RTL text you need to count down.
+     // So the following code tries to build the reverse map as expected
+     // by calling code.
+
+     storeGVData(env, gvdata, slot, baseIndex, startPt,
+                 glyphCount, glyphInfo, glyphPos, direction);
+
+     hb_buffer_destroy (buffer);
+     hb_font_destroy(hbfont);
+     free((void*)jdkFontInfo);
+     if (features != NULL) free(features);
+
+     return JNI_TRUE;
+}
+