Update from https://crrev.com/316786

third_party/harfbuzz-ng/src/hb-ft.cc

 /*
  * Copyright © 2009  Red Hat, Inc.
  * Copyright © 2009  Keith Stribley
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
@@ skipping 33 matching lines @@
 /* TODO:
  *
  * In general, this file does a fine job of what it's supposed to do.
  * There are, however, things that need more work:
  *
  *   - We don't handle any load_flags.  That definitely has API implications. :(
  *     I believe hb_ft_font_create() should take load_flags input.
  *     In particular, FT_Get_Advance() without the NO_HINTING flag seems to be
  *     buggy.
  *
+ *     FreeType works in 26.6 mode.  Clients can decide to use that mode, and everything
+ *     would work fine.  However, we also abuse this API for performing in font-space,
+ *     but don't pass the correct flags to FreeType.  We just abuse the no-hinting mode
+ *     for that, such that no rounding etc happens.  As such, we don't set ppem, and
+ *     pass NO_HINTING around.  This seems to work best, until we go ahead and add a full
+ *     load_flags API.
+ *
  *   - We don't handle / allow for emboldening / obliqueing.
  *
  *   - In the future, we should add constructors to create fonts in font space?
  *
  *   - FT_Load_Glyph() is exteremely costly.  Do something about it?
  */
 
 
 static hb_bool_t
 hb_ft_get_glyph (hb_font_t *font HB_UNUSED,
                  void *font_data,
                  hb_codepoint_t unicode,
                  hb_codepoint_t variation_selector,
                  hb_codepoint_t *glyph,
                  void *user_data HB_UNUSED)
 
 {
   FT_Face ft_face = (FT_Face) font_data;
 
-#ifdef HAVE_FT_FACE_GETCHARVARIANTINDEX
   if (unlikely (variation_selector)) {
     *glyph = FT_Face_GetCharVariantIndex (ft_face, unicode, variation_selector);
     return *glyph != 0;
   }
-#endif
 
   *glyph = FT_Get_Char_Index (ft_face, unicode);
   return *glyph != 0;
 }
 
 static hb_position_t
 hb_ft_get_glyph_h_advance (hb_font_t *font HB_UNUSED,
                            void *font_data,
                            hb_codepoint_t glyph,
                            void *user_data HB_UNUSED)
 {
   FT_Face ft_face = (FT_Face) font_data;
   int load_flags = FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING;
   FT_Fixed v;
 
   if (unlikely (FT_Get_Advance (ft_face, glyph, load_flags, &v)))
     return 0;
 
+  if (font->x_scale < 0)
+    v = -v;
+
   return (v + (1<<9)) >> 10;
 }
 
 static hb_position_t
 hb_ft_get_glyph_v_advance (hb_font_t *font HB_UNUSED,
                            void *font_data,
                            hb_codepoint_t glyph,
                            void *user_data HB_UNUSED)
 {
   FT_Face ft_face = (FT_Face) font_data;
@@ skipping 226 matching lines @@
 hb_ft_face_create (FT_Face           ft_face,
                    hb_destroy_func_t destroy)
 {
   hb_face_t *face;
 
   if (ft_face->stream->read == NULL) {
     hb_blob_t *blob;
 
     blob = hb_blob_create ((const char *) ft_face->stream->base,
                            (unsigned int) ft_face->stream->size,
-                           /* TODO: We assume that it's mmap()'ed, but FreeType code
-                            * suggests that there are cases we reach here but font is
-                            * not mmapped.  For example, when mmap() fails.  No idea
-                            * how to deal with it better here. */
-                           HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE,
+                           HB_MEMORY_MODE_READONLY,
                            ft_face, destroy);
     face = hb_face_create (blob, ft_face->face_index);
     hb_blob_destroy (blob);
   } else {
     face = hb_face_create_for_tables (reference_table, ft_face, destroy);
   }
 
   hb_face_set_index (face, ft_face->face_index);
   hb_face_set_upem (face, ft_face->units_per_EM);
 
   return face;
 }
 
+/**
+ * hb_ft_face_create_referenced:
+ * @ft_face:
+ *
+ * 
+ *
+ * Return value: (transfer full): 
+ * Since: 1.0
+ **/
+hb_face_t *
+hb_ft_face_create_referenced (FT_Face ft_face)
+{
+  FT_Reference_Face (ft_face);
+  return hb_ft_face_create (ft_face, (hb_destroy_func_t) FT_Done_Face);
+}
+
 static void
 hb_ft_face_finalize (FT_Face ft_face)
 {
   hb_face_destroy ((hb_face_t *) ft_face->generic.data);
 }
 
 /**
  * hb_ft_face_create_cached:
  * @ft_face: 
  *
@@ skipping 42 matching lines @@
 
   face = hb_ft_face_create (ft_face, destroy);
   font = hb_font_create (face);
   hb_face_destroy (face);
   hb_font_set_funcs (font,
                      _hb_ft_get_font_funcs (),
                      ft_face, (hb_destroy_func_t) _do_nothing);
   hb_font_set_scale (font,
                      (int) (((uint64_t) ft_face->size->metrics.x_scale * (uint64_t) ft_face->units_per_EM + (1<<15)) >> 16),
                      (int) (((uint64_t) ft_face->size->metrics.y_scale * (uint64_t) ft_face->units_per_EM + (1<<15)) >> 16));
+#if 0 /* hb-ft works in no-hinting model */
   hb_font_set_ppem (font,
                     ft_face->size->metrics.x_ppem,
                     ft_face->size->metrics.y_ppem);
+#endif
 
   return font;
 }
 
+/**
+ * hb_ft_font_create_referenced:
+ * @ft_face:
+ *
+ * 
+ *
+ * Return value: (transfer full): 
+ * Since: 1.0
+ **/
+hb_font_t *
+hb_ft_font_create_referenced (FT_Face ft_face)
+{
+  FT_Reference_Face (ft_face);
+  return hb_ft_font_create (ft_face, (hb_destroy_func_t) FT_Done_Face);
+}
+
 
 /* Thread-safe, lock-free, FT_Library */
 
 static FT_Library ft_library;
 
-static inline
+#ifdef HB_USE_ATEXIT
+static
 void free_ft_library (void)
 {
   FT_Done_FreeType (ft_library);
 }
+#endif
 
 static FT_Library
 get_ft_library (void)
 {
 retry:
   FT_Library library = (FT_Library) hb_atomic_ptr_get (&ft_library);
 
   if (unlikely (!library))
   {
     /* Not found; allocate one. */
@@ skipping 36 matching lines @@
                                      &ft_face);
 
   if (unlikely (err)) {
     hb_blob_destroy (blob);
     DEBUG_MSG (FT, font, "Font face FT_New_Memory_Face() failed");
     return;
   }
 
   FT_Select_Charmap (ft_face, FT_ENCODING_UNICODE);
 
-  assert (font->y_scale >= 0);
   FT_Set_Char_Size (ft_face,
-                    font->x_scale, font->y_scale,
+                    abs (font->x_scale), abs (font->y_scale),
                     0, 0);
 #if 0
                     font->x_ppem * 72 * 64 / font->x_scale,
                     font->y_ppem * 72 * 64 / font->y_scale);
 #endif
+  if (font->x_scale < 0 || font->y_scale < 0)
+  {
+    FT_Matrix matrix = { font->x_scale < 0 ? -1 : +1, 0,
+                          0, font->y_scale < 0 ? -1 : +1};
+    FT_Set_Transform (ft_face, &matrix, NULL);
+  }
 
   ft_face->generic.data = blob;
   ft_face->generic.finalizer = (FT_Generic_Finalizer) _release_blob;
 
   hb_font_set_funcs (font,
                      _hb_ft_get_font_funcs (),
                      ft_face,
                      (hb_destroy_func_t) FT_Done_Face);
 }
 
 FT_Face
 hb_ft_font_get_face (hb_font_t *font)
 {
   if (font->destroy == (hb_destroy_func_t) FT_Done_Face ||
       font->destroy == (hb_destroy_func_t) _do_nothing)
     return (FT_Face) font->user_data;
 
   return NULL;
 }