Update OTS to revision a7a3b94

third_party/ots/src/gdef.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gdef.h"
 
 #include <limits>
 #include <vector>
 
 #include "gpos.h"
@@ skipping 10 matching lines @@
 
 // The maximum class value in class definition tables.
 const uint16_t kMaxClassDefValue = 0xFFFF;
 // The maximum class value in the glyph class definision table.
 const uint16_t kMaxGlyphClassDefValue = 4;
 // The maximum format number of caret value tables.
 // We don't support format 3 for now. See the comment in
 // ParseLigCaretListTable() for the reason.
 const uint16_t kMaxCaretValueFormat = 2;
 
-bool ParseGlyphClassDefTable(ots::OpenTypeFile *file, const uint8_t *data,
+bool ParseGlyphClassDefTable(ots::Font *font, const uint8_t *data,
                              size_t length, const uint16_t num_glyphs) {
-  return ots::ParseClassDefTable(file, data, length, num_glyphs,
+  return ots::ParseClassDefTable(font, data, length, num_glyphs,
                                  kMaxGlyphClassDefValue);
 }
 
-bool ParseAttachListTable(ots::OpenTypeFile *file, const uint8_t *data,
+bool ParseAttachListTable(ots::Font *font, const uint8_t *data,
                           size_t length, const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   uint16_t offset_coverage = 0;
   uint16_t glyph_count = 0;
   if (!subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&glyph_count)) {
     return OTS_FAILURE_MSG("Failed to read gdef header");
   }
   const unsigned attach_points_end =
@@ skipping 15 matching lines @@
     if (!subtable.ReadU16(&attach_points[i])) {
       return OTS_FAILURE_MSG("Can't read attachment point %d", i);
     }
     if (attach_points[i] >= length ||
         attach_points[i] < attach_points_end) {
       return OTS_FAILURE_MSG("Bad attachment point %d of %d", i, attach_points[i]);
     }
   }
 
   // Parse coverage table
-  if (!ots::ParseCoverageTable(file, data + offset_coverage,
+  if (!ots::ParseCoverageTable(font, data + offset_coverage,
                                length - offset_coverage, num_glyphs)) {
     return OTS_FAILURE_MSG("Bad coverage table");
   }
 
   // Parse attach point table
   for (unsigned i = 0; i < attach_points.size(); ++i) {
     subtable.set_offset(attach_points[i]);
     uint16_t point_count = 0;
     if (!subtable.ReadU16(&point_count)) {
       return OTS_FAILURE_MSG("Can't read point count %d", i);
@@ skipping 11 matching lines @@
       if (last_point_index != 0 && last_point_index >= point_index) {
         return OTS_FAILURE_MSG("bad contour indeces: %u >= %u",
                     last_point_index, point_index);
       }
       last_point_index = point_index;
     }
   }
   return true;
 }
 
-bool ParseLigCaretListTable(ots::OpenTypeFile *file, const uint8_t *data,
+bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data,
                             size_t length, const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
   uint16_t offset_coverage = 0;
   uint16_t lig_glyph_count = 0;
   if (!subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&lig_glyph_count)) {
     return OTS_FAILURE_MSG("Can't read caret structure");
   }
   const unsigned lig_glyphs_end =
       2 * static_cast<unsigned>(lig_glyph_count) + 4;
@@ skipping 13 matching lines @@
   for (unsigned i = 0; i < lig_glyph_count; ++i) {
     if (!subtable.ReadU16(&lig_glyphs[i])) {
       return OTS_FAILURE_MSG("Can't read ligature glyph location %d", i);
     }
     if (lig_glyphs[i] >= length || lig_glyphs[i] < lig_glyphs_end) {
       return OTS_FAILURE_MSG("Bad ligature glyph location %d in glyph %d", lig_glyphs[i], i);
     }
   }
 
   // Parse coverage table
-  if (!ots::ParseCoverageTable(file, data + offset_coverage,
+  if (!ots::ParseCoverageTable(font, data + offset_coverage,
                                length - offset_coverage, num_glyphs)) {
     return OTS_FAILURE_MSG("Can't parse caret coverage table");
   }
 
   // Parse ligature glyph table
   for (unsigned i = 0; i < lig_glyphs.size(); ++i) {
     subtable.set_offset(lig_glyphs[i]);
     uint16_t caret_count = 0;
     if (!subtable.ReadU16(&caret_count)) {
       return OTS_FAILURE_MSG("Can't read caret count for glyph %d", i);
@@ skipping 30 matching lines @@
       // CaretValueFormats contain a 2-byte field which could be
       // arbitrary value.
       if (!subtable.Skip(2)) {
         return OTS_FAILURE_MSG("Bad caret value table structure %d in glyph %d", j, i);
       }
     }
   }
   return true;
 }
 
-bool ParseMarkAttachClassDefTable(ots::OpenTypeFile *file, const uint8_t *data,
+bool ParseMarkAttachClassDefTable(ots::Font *font, const uint8_t *data,
                                   size_t length, const uint16_t num_glyphs) {
-  return ots::ParseClassDefTable(file, data, length, num_glyphs, kMaxClassDefValue);
+  return ots::ParseClassDefTable(font, data, length, num_glyphs, kMaxClassDefValue);
 }
 
-bool ParseMarkGlyphSetsDefTable(ots::OpenTypeFile *file, const uint8_t *data,
+bool ParseMarkGlyphSetsDefTable(ots::Font *font, const uint8_t *data,
                                 size_t length, const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
   uint16_t format = 0;
   uint16_t mark_set_count = 0;
   if (!subtable.ReadU16(&format) ||
       !subtable.ReadU16(&mark_set_count)) {
     return OTS_FAILURE_MSG("Can' read mark glyph table structure");
   }
   if (format != 1) {
     return OTS_FAILURE_MSG("bad mark glyph set table format: %u", format);
   }
 
   const unsigned mark_sets_end = 2 * static_cast<unsigned>(mark_set_count) + 4;
   if (mark_sets_end > std::numeric_limits<uint16_t>::max()) {
     return OTS_FAILURE_MSG("Bad mark_set %d", mark_sets_end);
   }
   for (unsigned i = 0; i < mark_set_count; ++i) {
     uint32_t offset_coverage = 0;
     if (!subtable.ReadU32(&offset_coverage)) {
       return OTS_FAILURE_MSG("Can't read covrage location for mark set %d", i);
     }
     if (offset_coverage >= length ||
         offset_coverage < mark_sets_end) {
       return OTS_FAILURE_MSG("Bad coverage location %d for mark set %d", offset_coverage, i);
     }
-    if (!ots::ParseCoverageTable(file, data + offset_coverage,
+    if (!ots::ParseCoverageTable(font, data + offset_coverage,
                                  length - offset_coverage, num_glyphs)) {
       return OTS_FAILURE_MSG("Failed to parse coverage table for mark set %d", i);
     }
   }
-  file->gdef->num_mark_glyph_sets = mark_set_count;
+  font->gdef->num_mark_glyph_sets = mark_set_count;
   return true;
 }
 
 }  // namespace
 
 #define DROP_THIS_TABLE(msg_) \
   do { \
     OTS_FAILURE_MSG(msg_ ", table discarded"); \
-    file->gdef->data = 0; \
-    file->gdef->length = 0; \
+    font->gdef->data = 0; \
+    font->gdef->length = 0; \
   } while (0)
 
 namespace ots {
 
-bool ots_gdef_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
-  // Grab the number of glyphs in the file from the maxp table to check
+bool ots_gdef_parse(Font *font, const uint8_t *data, size_t length) {
+  // Grab the number of glyphs in the font from the maxp table to check
   // GlyphIDs in GDEF table.
-  if (!file->maxp) {
+  if (!font->maxp) {
     return OTS_FAILURE_MSG("No maxp table in font, needed by GDEF");
   }
-  const uint16_t num_glyphs = file->maxp->num_glyphs;
+  const uint16_t num_glyphs = font->maxp->num_glyphs;
 
   Buffer table(data, length);
 
   OpenTypeGDEF *gdef = new OpenTypeGDEF;
-  file->gdef = gdef;
+  font->gdef = gdef;
 
   uint32_t version = 0;
   if (!table.ReadU32(&version)) {
     DROP_THIS_TABLE("Incomplete table");
     return true;
   }
   if (version < 0x00010000 || version == 0x00010001) {
     DROP_THIS_TABLE("Bad version");
     return true;
   }
@@ skipping 25 matching lines @@
   if (gdef->version_2)
     gdef_header_end += 2;
 
   // Parse subtables
   if (offset_glyph_class_def) {
     if (offset_glyph_class_def >= length ||
         offset_glyph_class_def < gdef_header_end) {
       DROP_THIS_TABLE("Invalid offset to glyph classes");
       return true;
     }
-    if (!ParseGlyphClassDefTable(file, data + offset_glyph_class_def,
+    if (!ParseGlyphClassDefTable(font, data + offset_glyph_class_def,
                                  length - offset_glyph_class_def,
                                  num_glyphs)) {
       DROP_THIS_TABLE("Invalid glyph classes");
       return true;
     }
     gdef->has_glyph_class_def = true;
   }
 
   if (offset_attach_list) {
     if (offset_attach_list >= length ||
         offset_attach_list < gdef_header_end) {
       DROP_THIS_TABLE("Invalid offset to attachment list");
       return true;
     }
-    if (!ParseAttachListTable(file, data + offset_attach_list,
+    if (!ParseAttachListTable(font, data + offset_attach_list,
                               length - offset_attach_list,
                               num_glyphs)) {
       DROP_THIS_TABLE("Invalid attachment list");
       return true;
     }
   }
 
   if (offset_lig_caret_list) {
     if (offset_lig_caret_list >= length ||
         offset_lig_caret_list < gdef_header_end) {
       DROP_THIS_TABLE("Invalid offset to ligature caret list");
       return true;
     }
-    if (!ParseLigCaretListTable(file, data + offset_lig_caret_list,
+    if (!ParseLigCaretListTable(font, data + offset_lig_caret_list,
                               length - offset_lig_caret_list,
                               num_glyphs)) {
       DROP_THIS_TABLE("Invalid ligature caret list");
       return true;
     }
   }
 
   if (offset_mark_attach_class_def) {
     if (offset_mark_attach_class_def >= length ||
         offset_mark_attach_class_def < gdef_header_end) {
       return OTS_FAILURE_MSG("Invalid offset to mark attachment list");
     }
-    if (!ParseMarkAttachClassDefTable(file,
+    if (!ParseMarkAttachClassDefTable(font,
                                       data + offset_mark_attach_class_def,
                                       length - offset_mark_attach_class_def,
                                       num_glyphs)) {
       DROP_THIS_TABLE("Invalid mark attachment list");
       return true;
     }
     gdef->has_mark_attachment_class_def = true;
   }
 
   if (offset_mark_glyph_sets_def) {
     if (offset_mark_glyph_sets_def >= length ||
         offset_mark_glyph_sets_def < gdef_header_end) {
       return OTS_FAILURE_MSG("invalid offset to mark glyph sets");
     }
-    if (!ParseMarkGlyphSetsDefTable(file,
+    if (!ParseMarkGlyphSetsDefTable(font,
                                     data + offset_mark_glyph_sets_def,
                                     length - offset_mark_glyph_sets_def,
                                     num_glyphs)) {
       DROP_THIS_TABLE("Invalid mark glyph sets");
       return true;
     }
     gdef->has_mark_glyph_sets_def = true;
   }
   gdef->data = data;
   gdef->length = length;
   return true;
 }
 
-bool ots_gdef_should_serialise(OpenTypeFile *file) {
-  return file->gdef != NULL && file->gdef->data != NULL;
+bool ots_gdef_should_serialise(Font *font) {
+  return font->gdef != NULL && font->gdef->data != NULL;
 }
 
-bool ots_gdef_serialise(OTSStream *out, OpenTypeFile *file) {
-  if (!out->Write(file->gdef->data, file->gdef->length)) {
+bool ots_gdef_serialise(OTSStream *out, Font *font) {
+  if (!out->Write(font->gdef->data, font->gdef->length)) {
     return OTS_FAILURE_MSG("Failed to write GDEF table");
   }
 
   return true;
 }
 
-void ots_gdef_free(OpenTypeFile *file) {
-  delete file->gdef;
+void ots_gdef_reuse(Font *font, Font *other) {
+  font->gdef = other->gdef;
+  font->gdef_reused = true;
+}
+
+void ots_gdef_free(Font *font) {
+  delete font->gdef;
 }
 
 }  // namespace ots
 
 #undef TABLE_NAME
 #undef DROP_THIS_TABLE