Update harfbuzz-ng to 1a5a91dc0d8bf4b72a2f22dc6300b06ad7000b79.

third_party/harfbuzz-ng/src/hb-ot-layout-common-private.hh

 /*
- * Copyright (C) 2007,2008,2009  Red Hat, Inc.
- * Copyright (C) 2010  Google, Inc.
+ * Copyright © 2007,2008,2009  Red Hat, Inc.
+ * Copyright © 2010  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
  * all copies of this software.
  *
  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
@@ skipping 17 matching lines @@
 
 #include "hb-ot-layout-private.hh"
 
 #include "hb-open-type-private.hh"
 
 
 #define NO_CONTEXT              ((unsigned int) 0x110000)
 #define NOT_COVERED             ((unsigned int) 0x110000)
 #define MAX_NESTING_LEVEL       8
 
-HB_BEGIN_DECLS
-HB_END_DECLS
 
 
 /*
  *
  * OpenType Layout Common Table Formats
  *
  */
 
 
 /*
@@ skipping 29 matching lines @@
      * for Record types.  Instead, we return the correct Null(Tag)
      * here. */
     if (unlikely (i >= this->len)) return Null(Tag);
     return (*this)[i].tag;
   }
   inline unsigned int get_tags (unsigned int start_offset,
                                 unsigned int *record_count /* IN/OUT */,
                                 hb_tag_t     *record_tags /* OUT */) const
   {
     if (record_count) {
-      const Record<Type> *array = this->sub_array (start_offset, record_count);
+      const Record<Type> *arr = this->sub_array (start_offset, record_count);
       unsigned int count = *record_count;
       for (unsigned int i = 0; i < count; i++)
-        record_tags[i] = array[i].tag;
+        record_tags[i] = arr[i].tag;
     }
     return this->len;
   }
   inline bool find_index (hb_tag_t tag, unsigned int *index) const
   {
     int i = this->search (tag);
     if (i != -1) {
         if (index) *index = i;
         return true;
     } else {
@@ skipping 37 matching lines @@
 DEFINE_NULL_DATA (RangeRecord, "\000\001");
 
 
 struct IndexArray : ArrayOf<Index>
 {
   inline unsigned int get_indexes (unsigned int start_offset,
                                    unsigned int *_count /* IN/OUT */,
                                    unsigned int *_indexes /* OUT */) const
   {
     if (_count) {
-      const USHORT *array = this->sub_array (start_offset, _count);
+      const USHORT *arr = this->sub_array (start_offset, _count);
       unsigned int count = *_count;
       for (unsigned int i = 0; i < count; i++)
-        _indexes[i] = array[i];
+        _indexes[i] = arr[i];
     }
     return this->len;
   }
 };
 
 
 struct Script;
 struct LangSys;
 struct Feature;
 
@@ skipping 352 matching lines @@
 };
 
 
 /*
  * Device Tables
  */
 
 struct Device
 {
 
-  inline hb_position_t get_x_delta (hb_ot_layout_context_t *c) const
-  { return get_delta (c->font->x_ppem, c->font->x_scale); }
+  inline hb_position_t get_x_delta (hb_font_t *font) const
+  { return get_delta (font->x_ppem, font->x_scale); }
 
-  inline hb_position_t get_y_delta (hb_ot_layout_context_t *c) const
-  { return get_delta (c->font->y_ppem, c->font->y_scale); }
+  inline hb_position_t get_y_delta (hb_font_t *font) const
+  { return get_delta (font->y_ppem, font->y_scale); }
 
-  inline int get_delta (unsigned int ppem, unsigned int scale) const
+  inline int get_delta (unsigned int ppem, int scale) const
   {
     if (!ppem) return 0;
 
     int pixels = get_delta_pixels (ppem);
 
     if (!pixels) return 0;
 
-    /* pixels is at most in the -8..7 range.  So 64-bit arithmetic is
-     * not really necessary here.  A simple cast to int may just work
-     * as well.  But since this code is not reached that often and
-     * for the sake of correctness, we do a 64bit operation. */
     return pixels * (int64_t) scale / ppem;
   }
 
 
   inline int get_delta_pixels (unsigned int ppem_size) const
   {
     unsigned int f = deltaFormat;
     if (unlikely (f < 1 || f > 3))
       return 0;
 
@@ skipping 34 matching lines @@
                                          * 1    Signed 2-bit value, 8 values per uint16
                                          * 2    Signed 4-bit value, 4 values per uint16
                                          * 3    Signed 8-bit value, 2 values per uint16
                                          */
   USHORT        deltaValue[VAR];        /* Array of compressed data */
   public:
   DEFINE_SIZE_ARRAY (6, deltaValue);
 };
 
 
-HB_BEGIN_DECLS
-HB_END_DECLS
 
 #endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */