Update from https://crrev.com/316786

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

 /*
  * Copyright © 2012,2013  Mozilla Foundation.
  * Copyright © 2012,2013  Google, Inc.
  *
  *  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 122 matching lines @@
   return face_data;
 }
 
 
 /*
  * shaper font data
  */
 
 struct hb_coretext_shaper_font_data_t {
   CTFontRef ct_font;
+  CGFloat x_mult, y_mult; /* From CT space to HB space. */
 };
 
 hb_coretext_shaper_font_data_t *
 _hb_coretext_shaper_font_data_create (hb_font_t *font)
 {
   if (unlikely (!hb_coretext_shaper_face_data_ensure (font->face))) return NULL;
 
   hb_coretext_shaper_font_data_t *data = (hb_coretext_shaper_font_data_t *) calloc (1, sizeof (hb_coretext_shaper_font_data_t));
   if (unlikely (!data))
     return NULL;
 
   hb_face_t *face = font->face;
   hb_coretext_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
 
-  data->ct_font = CTFontCreateWithGraphicsFont (face_data, font->y_scale, NULL, NULL);
+  /* Choose a CoreText font size and calculate multipliers to convert to HarfBuzz space. */
+  CGFloat font_size = 36.; /* Default... */
+  /* No idea if the following is even a good idea. */
+  if (font->y_ppem)
+    font_size = font->y_ppem;
+
+  if (font_size < 0)
+    font_size = -font_size;
+  data->x_mult = (CGFloat) font->x_scale / font_size;
+  data->y_mult = (CGFloat) font->y_scale / font_size;
+  data->ct_font = CTFontCreateWithGraphicsFont (face_data, font_size, NULL, NULL);
   if (unlikely (!data->ct_font)) {
     DEBUG_MSG (CORETEXT, font, "Font CTFontCreateWithGraphicsFont() failed");
     free (data);
     return NULL;
   }
 
   return data;
 }
 
 void
@@ skipping 601 matching lines @@
       if (unlikely (!line))
         FAIL ("CTTypesetterCreateLine failed");
     }
 
     CFArrayRef glyph_runs = CTLineGetGlyphRuns (line);
     unsigned int num_runs = CFArrayGetCount (glyph_runs);
     DEBUG_MSG (CORETEXT, NULL, "Num runs: %d", num_runs);
 
     buffer->len = 0;
     uint32_t status_and = ~0, status_or = 0;
+    double advances_so_far = 0;
 
     const CFRange range_all = CFRangeMake (0, 0);
 
     for (unsigned int i = 0; i < num_runs; i++)
     {
       CTRunRef run = static_cast<CTRunRef>(CFArrayGetValueAtIndex (glyph_runs, i));
       CTRunStatus run_status = CTRunGetStatus (run);
       status_or  |= run_status;
       status_and &= run_status;
       DEBUG_MSG (CORETEXT, run, "CTRunStatus: %x", run_status);
+      double run_advance = CTRunGetTypographicBounds (run, range_all, NULL, NULL, NULL);
+      if (HB_DIRECTION_IS_VERTICAL (buffer->props.direction))
+          run_advance = -run_advance;
+      DEBUG_MSG (CORETEXT, run, "Run advance: %g", run_advance);
 
       /* CoreText does automatic font fallback (AKA "cascading") for  characters
        * not supported by the requested font, and provides no way to turn it off,
        * so we must detect if the returned run uses a font other than the requested
        * one and fill in the buffer with .notdef glyphs instead of random glyph
        * indices from a different font.
        */
       CFDictionaryRef attributes = CTRunGetAttributes (run);
       CTFontRef run_ct_font = static_cast<CTFontRef>(CFDictionaryGetValue (attributes, kCTFontAttributeName));
       if (!CFEqual (run_ct_font, font_data->ct_font))
@@ skipping 54 matching lines @@
         }
         if (!matched)
         {
           CFRange range = CTRunGetStringRange (run);
           DEBUG_MSG (CORETEXT, run, "Run used fallback font: %ld..%ld",
                      range.location, range.location + range.length);
           if (!buffer->ensure_inplace (buffer->len + range.length))
             goto resize_and_retry;
           hb_glyph_info_t *info = buffer->info + buffer->len;
 
-          CGGlyph notdef = 0;
-          double advance = CTFontGetAdvancesForGlyphs (font_data->ct_font, kCTFontHorizontalOrientation, &notdef, NULL, 1);
+          hb_codepoint_t notdef = 0;
+          hb_direction_t dir = buffer->props.direction;
+          hb_position_t x_advance, y_advance, x_offset, y_offset;
+          hb_font_get_glyph_advance_for_direction (font, notdef, dir, &x_advance, &y_advance);
+          hb_font_get_glyph_origin_for_direction (font, notdef, dir, &x_offset, &y_offset);
+          hb_position_t advance = x_advance + y_advance;
+          x_offset = -x_offset;
+          y_offset = -y_offset;
 
           unsigned int old_len = buffer->len;
           for (CFIndex j = range.location; j < range.location + range.length; j++)
           {
               UniChar ch = CFStringGetCharacterAtIndex (string_ref, j);
               if (hb_in_range<UniChar> (ch, 0xDC00u, 0xDFFFu) && range.location < j)
               {
                 ch = CFStringGetCharacterAtIndex (string_ref, j - 1);
                 if (hb_in_range<UniChar> (ch, 0xD800u, 0xDBFFu))
                   /* This is the second of a surrogate pair.  Don't need .notdef
                    * for this one. */
                   continue;
               }
+              if (buffer->unicode->is_default_ignorable (ch))
+                continue;
 
               info->codepoint = notdef;
               info->cluster = log_clusters[j];
 
               info->mask = advance;
-              info->var1.u32 = 0;
-              info->var2.u32 = 0;
+              info->var1.u32 = x_offset;
+              info->var2.u32 = y_offset;
 
               info++;
               buffer->len++;
           }
           if (HB_DIRECTION_IS_BACKWARD (buffer->props.direction))
             buffer->reverse_range (old_len, buffer->len);
+          advances_so_far += run_advance;
           continue;
         }
       }
 
       unsigned int num_glyphs = CTRunGetGlyphCount (run);
       if (num_glyphs == 0)
         continue;
 
       if (!buffer->ensure_inplace (buffer->len + num_glyphs))
         goto resize_and_retry;
 
       hb_glyph_info_t *run_info = buffer->info + buffer->len;
 
       /* Testing used to indicate that CTRunGetGlyphsPtr, etc (almost?) always
        * succeed, and so copying data to our own buffer will be rare.  Reports
        * have it that this changed in OS X 10.10 Yosemite, and NULL is returned
        * frequently.  At any rate, we can test that codepath by setting USE_PTR
        * to false. */
 
 #define USE_PTR true
 
 #define SCRATCH_SAVE() \
   unsigned int scratch_size_saved = scratch_size; \
   hb_buffer_t::scratch_buffer_t *scratch_saved = scratch
 
 #define SCRATCH_RESTORE() \
   scratch_size = scratch_size_saved; \
   scratch = scratch_saved;
 
-      {
+      { /* Setup glyphs */
         SCRATCH_SAVE();
         const CGGlyph* glyphs = USE_PTR ? CTRunGetGlyphsPtr (run) : NULL;
         if (!glyphs) {
           ALLOCATE_ARRAY (CGGlyph, glyph_buf, num_glyphs, goto resize_and_retry);
           CTRunGetGlyphs (run, range_all, glyph_buf);
           glyphs = glyph_buf;
         }
         const CFIndex* string_indices = USE_PTR ? CTRunGetStringIndicesPtr (run) : NULL;
         if (!string_indices) {
           ALLOCATE_ARRAY (CFIndex, index_buf, num_glyphs, goto resize_and_retry);
           CTRunGetStringIndices (run, range_all, index_buf);
           string_indices = index_buf;
         }
         hb_glyph_info_t *info = run_info;
         for (unsigned int j = 0; j < num_glyphs; j++)
         {
           info->codepoint = glyphs[j];
           info->cluster = log_clusters[string_indices[j]];
           info++;
         }
         SCRATCH_RESTORE();
       }
       {
+        /* Setup positions.
+         * Note that CoreText does not return advances for glyphs.  As such,
+         * for all but last glyph, we use the delta position to next glyph as
+         * advance (in the advance direction only), and for last glyph we set
+         * whatever is needed to make the whole run's advance add up. */
         SCRATCH_SAVE();
         const CGPoint* positions = USE_PTR ? CTRunGetPositionsPtr (run) : NULL;
         if (!positions) {
           ALLOCATE_ARRAY (CGPoint, position_buf, num_glyphs, goto resize_and_retry);
           CTRunGetPositions (run, range_all, position_buf);
           positions = position_buf;
         }
-        double run_advance = CTRunGetTypographicBounds (run, range_all, NULL, NULL, NULL);
-        DEBUG_MSG (CORETEXT, run, "Run advance: %g", run_advance);
         hb_glyph_info_t *info = run_info;
+        CGFloat x_mult = font_data->x_mult, y_mult = font_data->y_mult;
         if (HB_DIRECTION_IS_HORIZONTAL (buffer->props.direction))
         {
+          hb_position_t x_offset = (positions[0].x - advances_so_far) * x_mult;
           for (unsigned int j = 0; j < num_glyphs; j++)
           {
-            double advance = (j + 1 < num_glyphs ? positions[j + 1].x : positions[0].x + run_advance) - positions[j].x;
-            info->mask = advance;
-            info->var1.u32 = positions[0].x; /* Yes, zero. */
-            info->var2.u32 = positions[j].y;
+            double advance;
+            if (likely (j + 1 < num_glyphs))
+              advance = positions[j + 1].x - positions[j].x;
+            else /* last glyph */
+              advance = run_advance - (positions[j].x - positions[0].x);
+            info->mask = advance * x_mult;
+            info->var1.u32 = x_offset;
+            info->var2.u32 = positions[j].y * y_mult;
             info++;
           }
         }
         else
         {
-          run_advance = -run_advance;
+          hb_position_t y_offset = (positions[0].y - advances_so_far) * y_mult;
           for (unsigned int j = 0; j < num_glyphs; j++)
           {
-            double advance = (j + 1 < num_glyphs ? positions[j + 1].y : positions[0].y + run_advance) - positions[j].y;
-            info->mask = advance;
-            info->var1.u32 = positions[j].x;
-            info->var2.u32 = positions[0].y; /* Yes, zero. */
+            double advance;
+            if (likely (j + 1 < num_glyphs))
+              advance = positions[j + 1].y - positions[j].y;
+            else /* last glyph */
+              advance = run_advance - (positions[j].y - positions[0].y);
+            info->mask = advance * y_mult;
+            info->var1.u32 = positions[j].x * x_mult;
+            info->var2.u32 = y_offset;
             info++;
           }
         }
         SCRATCH_RESTORE();
+        advances_so_far += run_advance;
       }
 #undef SCRATCH_RESTORE
 #undef SCRATCH_SAVE
 #undef USE_PTR
 #undef ALLOCATE_ARRAY
 
       buffer->len += num_glyphs;
     }
 
     /* Make sure all runs had the expected direction. */
@@ skipping 158 matching lines @@
 
 hb_bool_t
 _hb_coretext_aat_shape (hb_shape_plan_t    *shape_plan,
                         hb_font_t          *font,
                         hb_buffer_t        *buffer,
                         const hb_feature_t *features,
                         unsigned int        num_features)
 {
   return _hb_coretext_shape (shape_plan, font, buffer, features, num_features);
 }