[ot-color] Cosmetic changes (#962)

src/hb-open-type-private.hh

@@ -909,7 +909,6 @@ struct UnsizedArrayOf
     return_trace (true);
   }
 
-  private:
   inline bool sanitize_shallow (hb_sanitize_context_t *c, unsigned int count) const
   {
     TRACE_SANITIZE (this);

src/hb-ot-color-cbdt-table.hh

@@ -301,23 +301,23 @@ struct BitmapSizeTable
 
 struct GlyphBitmapDataFormat17
 {
-  SmallGlyphMetrics		glyphMetrics;
-  ArrayOf<HBUINT8, HBUINT32>	data;
+  SmallGlyphMetrics	glyphMetrics;
+  LArrayOf<HBUINT8>	data;
   public:
   DEFINE_SIZE_ARRAY(9, data);
 };
 
 struct GlyphBitmapDataFormat18
 {
-  BigGlyphMetrics		glyphMetrics;
-  ArrayOf<HBUINT8, HBUINT32>	data;
+  BigGlyphMetrics	glyphMetrics;
+  LArrayOf<HBUINT8>	data;
   public:
   DEFINE_SIZE_ARRAY(12, data);
 };
 
 struct GlyphBitmapDataFormat19
 {
-  ArrayOf<HBUINT8, HBUINT32>	data;
+  LArrayOf<HBUINT8>	data;
   public:
   DEFINE_SIZE_ARRAY(4, data);
 };

src/hb-ot-color-cpal-table.hh

@@ -144,13 +144,13 @@ struct CPAL
   {
     TRACE_SANITIZE (this);
     if (!(c->check_struct (this) && // it checks colorRecordIndices also, see #get_size
-          (this+colorRecordsZ).sanitize (c, numColorRecords)))
+	  (this+colorRecordsZ).sanitize (c, numColorRecords)))
       return_trace (false);
 
     // Check for indices sanity so no need for doing it runtime
     for (unsigned int i = 0; i < numPalettes; ++i)
       if (colorRecordIndicesZ[i] + numPaletteEntries > numColorRecords)
-        return_trace (false);
+	return_trace (false);
 
     // If version is zero, we are done here; otherwise we need to check tail also
     if (version == 0)

src/hb-ot-color-sbix-table.hh

@@ -45,7 +45,8 @@ struct SBIXGlyph
   Tag		graphicType;	/* Indicates the format of the embedded graphic
 				 * data: one of 'jpg ', 'png ' or 'tiff', or the
 				 * special format 'dupe'. */
-  HBUINT8	data[VAR];	/* The actual embedded graphic data. The total
+  UnsizedArrayOf<HBUINT8>
+		data;		/* The actual embedded graphic data. The total
 				 * length is inferred from sequential entries in
 				 * the glyphDataOffsets array and the fixed size
 				 * (8 bytes) of the preceding fields. */
@@ -61,18 +62,16 @@ struct SBIXStrike
   {
     TRACE_SANITIZE (this);
     return_trace (c->check_struct (this) &&
-		  c->check_array (imageOffsetsZ,
-				  sizeof (HBUINT32),
-				  1 + c->num_glyphs));
+		  imageOffsetsZ.sanitize_shallow (c, c->num_glyphs + 1));
   }
 
-  HBUINT16		ppem;		/* The PPEM size for which this strike was designed. */
-  HBUINT16		resolution;	/* The device pixel density (in PPI) for which this
-					 * strike was designed. (E.g., 96 PPI, 192 PPI.) */
   protected:
-  LOffsetTo<SBIXGlyph>	imageOffsetsZ[VAR]; // VAR=maxp.numGlyphs + 1
-					/* Offset from the beginning of the strike data header
-					 * to bitmap data for an individual glyph ID. */
+  HBUINT16	ppem;		/* The PPEM size for which this strike was designed. */
+  HBUINT16	resolution;	/* The device pixel density (in PPI) for which this
+				 * strike was designed. (E.g., 96 PPI, 192 PPI.) */
+  UnsizedArrayOf<LOffsetTo<SBIXGlyph> >
+		imageOffsetsZ;	/* Offset from the beginning of the strike data header
+				 * to bitmap data for an individual glyph ID. */
   public:
   DEFINE_SIZE_STATIC (8);
 };
@@ -112,19 +111,19 @@ struct sbix
     }
 
     inline void dump (void (*callback) (const uint8_t* data, unsigned int length,
-        unsigned int group, unsigned int gid)) const
+					unsigned int group, unsigned int gid)) const
     {
       for (unsigned group = 0; group < sbix_table->strikes.len; ++group)
       {
-        const SBIXStrike &strike = sbix_table->strikes[group](sbix_table);
-        for (unsigned int glyph = 0; glyph < num_glyphs; ++glyph)
-          if (strike.imageOffsetsZ[glyph + 1] - strike.imageOffsetsZ[glyph] > 0)
-          {
-            const SBIXGlyph &sbixGlyph = strike.imageOffsetsZ[glyph]((const void *) &strike);
-            callback ((const uint8_t*) sbixGlyph.data,
-              strike.imageOffsetsZ[glyph + 1] - strike.imageOffsetsZ[glyph] - 8,
-              group, glyph);
-          }
+	const SBIXStrike &strike = sbix_table->strikes[group](sbix_table);
+	for (unsigned int glyph = 0; glyph < num_glyphs; ++glyph)
+	  if (strike.imageOffsetsZ[glyph + 1] - strike.imageOffsetsZ[glyph] > 0)
+	  {
+	    const SBIXGlyph &sbixGlyph = strike.imageOffsetsZ[glyph]((const void *) &strike);
+	    callback ((const uint8_t*) &sbixGlyph.data,
+		      strike.imageOffsetsZ[glyph + 1] - strike.imageOffsetsZ[glyph] - 8,
+		      group, glyph);
+	  }
       }
     }
 
@@ -141,7 +140,7 @@ struct sbix
   HBUINT16	version;	/* Table version number — set to 1 */
   HBUINT16	flags;		/* Bit 0: Set to 1. Bit 1: Draw outlines.
 				 * Bits 2 to 15: reserved (set to 0). */
-  ArrayOf<LOffsetTo<SBIXStrike>, HBUINT32>
+  LArrayOf<LOffsetTo<SBIXStrike> >
 		strikes;	/* Offsets from the beginning of the 'sbix'
 				 * table to data for each individual bitmap strike. */
   public:

src/hb-ot-color-svg-table.hh

@@ -45,19 +45,19 @@ struct SVGDocumentIndexEntry
   {
     TRACE_SANITIZE (this);
     return_trace (c->check_struct (this) &&
-      c->check_range (&svgDoc (base), svgDocLength));
+		  (base+svgDoc).sanitize (c, svgDocLength));
   }
 
   protected:
-  HBUINT16 startGlyphID;	/* The first glyph ID in the range described by
-                                 * this index entry. */
-  HBUINT16 endGlyphID;		/* The last glyph ID in the range described by
-                                 * this index entry. Must be >= startGlyphID. */
-  LOffsetTo<const uint8_t *>
-        svgDoc;			/* Offset from the beginning of the SVG Document Index
-                                 * to an SVG document. Must be non-zero. */
+  HBUINT16	startGlyphID;	/* The first glyph ID in the range described by
+				 * this index entry. */
+  HBUINT16	endGlyphID;	/* The last glyph ID in the range described by
+				 * this index entry. Must be >= startGlyphID. */
+  LOffsetTo<UnsizedArrayOf<HBUINT8> >
+		svgDoc;		/* Offset from the beginning of the SVG Document Index
+				 * to an SVG document. Must be non-zero. */
   HBUINT32 svgDocLength;	/* Length of the SVG document.
-                                 * Must be non-zero. */
+				 * Must be non-zero. */
   public:
   DEFINE_SIZE_STATIC (12);
 };
@@ -75,7 +75,7 @@ struct SVGDocumentIndex
 
   protected:
   ArrayOf<SVGDocumentIndexEntry>
-    entries;			/* Array of SVG Document Index Entries. */
+		entries;	/* Array of SVG Document Index Entries. */
   public:
   DEFINE_SIZE_ARRAY (2, entries);
 };
@@ -88,7 +88,7 @@ struct SVG
   {
     TRACE_SANITIZE (this);
     return_trace (c->check_struct (this) &&
-      svgDocIndex (this).sanitize (c));
+		  (this+svgDocIndex).sanitize (c));
   }
 
   struct accelerator_t
@@ -107,16 +107,17 @@ struct SVG
       hb_blob_destroy (svg_blob);
     }
 
-    inline void dump (void (*callback) (const uint8_t* data, unsigned int length,
-        unsigned int start_glyph, unsigned int end_glyph)) const
+    inline void
+    dump (void (*callback) (const uint8_t* data, unsigned int length,
+			    unsigned int start_glyph, unsigned int end_glyph)) const
     {
-      const SVGDocumentIndex &index = svg->svgDocIndex (svg);
+      const SVGDocumentIndex &index = svg+svg->svgDocIndex;
       const ArrayOf<SVGDocumentIndexEntry> &entries = index.entries;
       for (unsigned int i = 0; i < entries.len; ++i)
       {
-        const SVGDocumentIndexEntry &entry = entries[i];
-        callback ((const uint8_t*) &entry.svgDoc (&index), entry.svgDocLength,
-          entry.startGlyphID, entry.endGlyphID);
+	const SVGDocumentIndexEntry &entry = entries[i];
+	callback ((const uint8_t*) &entry.svgDoc (&index), entry.svgDocLength,
+						  entry.startGlyphID, entry.endGlyphID);
       }
     }
 
@@ -130,7 +131,7 @@ struct SVG
   protected:
   HBUINT16	version;	/* Table version (starting at 0). */
   LOffsetTo<SVGDocumentIndex>
-    svgDocIndex;		/* Offset (relative to the start of the SVG table) to the
+		svgDocIndex;	/* Offset (relative to the start of the SVG table) to the
 				 * SVG Documents Index. Must be non-zero. */
   HBUINT32	reserved;	/* Set to 0. */
   public: