Update harfbuzz-ng to 0.9.14 from 0.9.10

third_party/harfbuzz-ng/src/hb-ot-shape.cc

 /*
  * Copyright © 2009,2010  Red Hat, Inc.
  * Copyright © 2010,2011,2012  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 65 matching lines @@
 static void
 hb_ot_shape_collect_features (hb_ot_shape_planner_t          *planner,
                               const hb_segment_properties_t  *props,
                               const hb_feature_t             *user_features,
                               unsigned int                    num_user_features)
 {
   hb_ot_map_builder_t *map = &planner->map;
 
   switch (props->direction) {
     case HB_DIRECTION_LTR:
-      map->add_bool_feature (HB_TAG ('l','t','r','a'));
-      map->add_bool_feature (HB_TAG ('l','t','r','m'));
+      map->add_global_bool_feature (HB_TAG ('l','t','r','a'));
+      map->add_global_bool_feature (HB_TAG ('l','t','r','m'));
       break;
     case HB_DIRECTION_RTL:
-      map->add_bool_feature (HB_TAG ('r','t','l','a'));
-      map->add_bool_feature (HB_TAG ('r','t','l','m'), false);
+      map->add_global_bool_feature (HB_TAG ('r','t','l','a'));
+      map->add_feature (HB_TAG ('r','t','l','m'), 1, F_NONE);
       break;
     case HB_DIRECTION_TTB:
     case HB_DIRECTION_BTT:
     case HB_DIRECTION_INVALID:
     default:
       break;
   }
 
-#define ADD_FEATURES(array) \
-  HB_STMT_START { \
-    for (unsigned int i = 0; i < ARRAY_LENGTH (array); i++) \
-      map->add_bool_feature (array[i]); \
-  } HB_STMT_END
-
   if (planner->shaper->collect_features)
     planner->shaper->collect_features (planner);
 
-  ADD_FEATURES (common_features);
+  for (unsigned int i = 0; i < ARRAY_LENGTH (common_features); i++)
+    map->add_global_bool_feature (common_features[i]);
 
   if (HB_DIRECTION_IS_HORIZONTAL (props->direction))
-    ADD_FEATURES (horizontal_features);
+    for (unsigned int i = 0; i < ARRAY_LENGTH (horizontal_features); i++)
+      map->add_feature (horizontal_features[i], 1, F_GLOBAL |
+                        (horizontal_features[i] == HB_TAG('k','e','r','n') ?
+                         F_HAS_FALLBACK : F_NONE));
   else
-    ADD_FEATURES (vertical_features);
+    for (unsigned int i = 0; i < ARRAY_LENGTH (vertical_features); i++)
+      map->add_feature (vertical_features[i], 1, F_GLOBAL |
+                        (vertical_features[i] == HB_TAG('v','k','r','n') ?
+                         F_HAS_FALLBACK : F_NONE));
 
   if (planner->shaper->override_features)
     planner->shaper->override_features (planner);
 
-#undef ADD_FEATURES
-
   for (unsigned int i = 0; i < num_user_features; i++) {
     const hb_feature_t *feature = &user_features[i];
-    map->add_feature (feature->tag, feature->value, (feature->start == 0 && feature->end == (unsigned int) -1));
+    map->add_feature (feature->tag, feature->value,
+                      (feature->start == 0 && feature->end == (unsigned int) -1) ?
+                       F_GLOBAL : F_NONE);
   }
 }
 
 
 /*
  * shaper face data
  */
 
 hb_ot_shaper_face_data_t *
 _hb_ot_shaper_face_data_create (hb_face_t *face)
@@ skipping 264 matching lines @@
 }
 
 /* Position */
 
 static inline void
 hb_ot_position_default (hb_ot_shape_context_t *c)
 {
   hb_ot_layout_position_start (c->font, c->buffer);
 
   unsigned int count = c->buffer->len;
-  for (unsigned int i = 0; i < count; i++) {
+  for (unsigned int i = 0; i < count; i++)
+  {
     c->font->get_glyph_advance_for_direction (c->buffer->info[i].codepoint,
                                               c->buffer->props.direction,
                                               &c->buffer->pos[i].x_advance,
                                               &c->buffer->pos[i].y_advance);
     c->font->subtract_glyph_origin_for_direction (c->buffer->info[i].codepoint,
                                                   c->buffer->props.direction,
                                                   &c->buffer->pos[i].x_offset,
                                                   &c->buffer->pos[i].y_offset);
+
+  }
+
+  /* Zero'ing mark widths by GDEF (as used in Myanmar spec) happens
+   * *before* GPOS. */
+  switch (c->plan->shaper->zero_width_marks)
+  {
+    case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF:
+      for (unsigned int i = 0; i < count; i++)
+        if ((c->buffer->info[i].glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_MARK))
+        {
+          c->buffer->pos[i].x_advance = 0;
+          c->buffer->pos[i].y_advance = 0;
+        }
+      break;
+
+    default:
+    case HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE:
+    case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE:
+      break;
   }
 }
 
 static inline bool
 hb_ot_position_complex (hb_ot_shape_context_t *c)
 {
   bool ret = false;
+  unsigned int count = c->buffer->len;
 
   if (hb_ot_layout_has_positioning (c->face))
   {
     /* Change glyph origin to what GPOS expects, apply GPOS, change it back. */
 
-    unsigned int count = c->buffer->len;
     for (unsigned int i = 0; i < count; i++) {
       c->font->add_glyph_origin_for_direction (c->buffer->info[i].codepoint,
                                                HB_DIRECTION_LTR,
                                                &c->buffer->pos[i].x_offset,
                                                &c->buffer->pos[i].y_offset);
     }
 
     c->plan->position (c->font, c->buffer);
 
     for (unsigned int i = 0; i < count; i++) {
       c->font->subtract_glyph_origin_for_direction (c->buffer->info[i].codepoint,
                                                     HB_DIRECTION_LTR,
                                                     &c->buffer->pos[i].x_offset,
                                                     &c->buffer->pos[i].y_offset);
     }
 
     ret = true;
   }
 
-  hb_ot_layout_position_finish (c->font, c->buffer, c->plan->shaper->zero_width_attached_marks);
+  /* Zero'ing mark widths by Unicode happens
+   * *after* GPOS. */
+  switch (c->plan->shaper->zero_width_marks)
+  {
+    case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE:
+      for (unsigned int i = 0; i < count; i++)
+        if (_hb_glyph_info_get_general_category (&c->buffer->info[i]) == HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)
+        {
+          c->buffer->pos[i].x_advance = 0;
+          c->buffer->pos[i].y_advance = 0;
+        }
+      break;
+
+    default:
+    case HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE:
+    case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF:
+      break;
+  }
+
+  hb_ot_layout_position_finish (c->font, c->buffer);
 
   return ret;
 }
 
 static inline void
-hb_ot_truetype_kern (hb_ot_shape_context_t *c)
-{
-  /* TODO Check for kern=0 */
-  unsigned int count = c->buffer->len;
-  for (unsigned int i = 1; i < count; i++) {
-    hb_position_t x_kern, y_kern, kern1, kern2;
-    c->font->get_glyph_kerning_for_direction (c->buffer->info[i - 1].codepoint, c->buffer->info[i].codepoint,
-                                              c->buffer->props.direction,
-                                              &x_kern, &y_kern);
-
-    kern1 = x_kern >> 1;
-    kern2 = x_kern - kern1;
-    c->buffer->pos[i - 1].x_advance += kern1;
-    c->buffer->pos[i].x_advance += kern2;
-    c->buffer->pos[i].x_offset += kern2;
-
-    kern1 = y_kern >> 1;
-    kern2 = y_kern - kern1;
-    c->buffer->pos[i - 1].y_advance += kern1;
-    c->buffer->pos[i].y_advance += kern2;
-    c->buffer->pos[i].y_offset += kern2;
-  }
-}
-
-static inline void
 hb_ot_position (hb_ot_shape_context_t *c)
 {
   hb_ot_position_default (c);
 
   hb_bool_t fallback = !hb_ot_position_complex (c);
 
   if (fallback && c->plan->shaper->fallback_position)
     _hb_ot_shape_fallback_position (c->plan, c->font, c->buffer);
 
   if (HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction))
     hb_buffer_reverse (c->buffer);
 
   /* Visual fallback goes here. */
 
   if (fallback)
-    hb_ot_truetype_kern (c);
+    _hb_ot_shape_fallback_kern (c->plan, c->font, c->buffer);
 }
 
 
 /* Post-process */
 
 static void
 hb_ot_hide_default_ignorables (hb_ot_shape_context_t *c)
 {
   if (c->buffer->flags & HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES)
     return;
@@ skipping 98 matching lines @@
 
 void
 hb_ot_shape_glyphs_closure (hb_font_t          *font,
                             hb_buffer_t        *buffer,
                             const hb_feature_t *features,
                             unsigned int        num_features,
                             hb_set_t           *glyphs)
 {
   hb_ot_shape_plan_t plan;
 
-  buffer->guess_segment_properties ();
-
   const char *shapers[] = {"ot", NULL};
   hb_shape_plan_t *shape_plan = hb_shape_plan_create_cached (font->face, &buffer->props,
                                                              features, num_features, shapers);
 
   bool mirror = hb_script_get_horizontal_direction (buffer->props.script) == HB_DIRECTION_RTL;
 
   unsigned int count = buffer->len;
   for (unsigned int i = 0; i < count; i++)
     add_char (font, buffer->unicode, mirror, buffer->info[i].codepoint, glyphs);
 
   hb_set_t lookups;
   lookups.init ();
   hb_ot_shape_plan_collect_lookups (shape_plan, HB_OT_TAG_GSUB, &lookups);
 
   /* And find transitive closure. */
   hb_set_t copy;
   copy.init ();
   do {
     copy.set (glyphs);
     for (hb_codepoint_t lookup_index = -1; hb_set_next (&lookups, &lookup_index);)
       hb_ot_layout_lookup_substitute_closure (font->face, lookup_index, glyphs);
   } while (!copy.is_equal (glyphs));
 
   hb_shape_plan_destroy (shape_plan);
 }