Update OTS to revision 99a3b7f

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 211 matching lines @@
                                  length - offset_coverage, num_glyphs)) {
       return OTS_FAILURE_MSG("Failed to parse coverage table for mark set %d", i);
     }
   }
   font->gdef->num_mark_glyph_sets = mark_set_count;
   return true;
 }
 
 }  // namespace
 
-#define DROP_THIS_TABLE(msg_) \
-  do { \
-    OTS_FAILURE_MSG(msg_ ", table discarded"); \
-    font->gdef->data = 0; \
-    font->gdef->length = 0; \
-  } while (0)
-
 namespace ots {
 
 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 (!font->maxp) {
     return OTS_FAILURE_MSG("No maxp table in font, needed by GDEF");
   }
   const uint16_t num_glyphs = font->maxp->num_glyphs;
 
   Buffer table(data, length);
 
   OpenTypeGDEF *gdef = new OpenTypeGDEF;
   font->gdef = gdef;
 
   uint32_t version = 0;
   if (!table.ReadU32(&version)) {
-    DROP_THIS_TABLE("Incomplete table");
-    return true;
+    return OTS_FAILURE_MSG("Incomplete table");
   }
   if (version < 0x00010000 || version == 0x00010001) {
-    DROP_THIS_TABLE("Bad version");
-    return true;
+    return OTS_FAILURE_MSG("Bad version");
   }
 
   if (version >= 0x00010002) {
     gdef->version_2 = true;
   }
 
   uint16_t offset_glyph_class_def = 0;
   uint16_t offset_attach_list = 0;
   uint16_t offset_lig_caret_list = 0;
   uint16_t offset_mark_attach_class_def = 0;
   if (!table.ReadU16(&offset_glyph_class_def) ||
       !table.ReadU16(&offset_attach_list) ||
       !table.ReadU16(&offset_lig_caret_list) ||
       !table.ReadU16(&offset_mark_attach_class_def)) {
-    DROP_THIS_TABLE("Incomplete table");
-    return true;
+    return OTS_FAILURE_MSG("Incomplete table");
   }
   uint16_t offset_mark_glyph_sets_def = 0;
   if (gdef->version_2) {
     if (!table.ReadU16(&offset_mark_glyph_sets_def)) {
-      DROP_THIS_TABLE("Incomplete table");
-      return true;
+      return OTS_FAILURE_MSG("Incomplete table");
     }
   }
 
   unsigned gdef_header_end = 4 + 4 * 2;
   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;
+      return OTS_FAILURE_MSG("Invalid offset to glyph classes");
     }
     if (!ParseGlyphClassDefTable(font, data + offset_glyph_class_def,
                                  length - offset_glyph_class_def,
                                  num_glyphs)) {
-      DROP_THIS_TABLE("Invalid glyph classes");
-      return true;
+      return OTS_FAILURE_MSG("Invalid glyph classes");
     }
     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;
+      return OTS_FAILURE_MSG("Invalid offset to attachment list");
     }
     if (!ParseAttachListTable(font, data + offset_attach_list,
                               length - offset_attach_list,
                               num_glyphs)) {
-      DROP_THIS_TABLE("Invalid attachment list");
-      return true;
+      return OTS_FAILURE_MSG("Invalid attachment list");
     }
   }
 
   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;
+      return OTS_FAILURE_MSG("Invalid offset to ligature 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;
+      return OTS_FAILURE_MSG("Invalid ligature caret list");
     }
   }
 
   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(font,
                                       data + offset_mark_attach_class_def,
                                       length - offset_mark_attach_class_def,
                                       num_glyphs)) {
-      DROP_THIS_TABLE("Invalid mark attachment list");
-      return true;
+      return OTS_FAILURE_MSG("Invalid mark attachment list");
     }
     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(font,
                                     data + offset_mark_glyph_sets_def,
                                     length - offset_mark_glyph_sets_def,
                                     num_glyphs)) {
-      DROP_THIS_TABLE("Invalid mark glyph sets");
-      return true;
+      return OTS_FAILURE_MSG("Invalid mark glyph sets");
     }
     gdef->has_mark_glyph_sets_def = true;
   }
   gdef->data = data;
   gdef->length = length;
   return true;
 }
 
 bool ots_gdef_should_serialise(Font *font) {
   return font->gdef != NULL && font->gdef->data != NULL;
@@ skipping 12 matching lines @@
   font->gdef_reused = true;
 }
 
 void ots_gdef_free(Font *font) {
   delete font->gdef;
 }
 
 }  // namespace ots
 
 #undef TABLE_NAME
-#undef DROP_THIS_TABLE