Merge branch 'master' into mailnews-work

1 files changed, 130 insertions, 139 deletions

diff --git a/gfx/ots/src/gdef.cc b/gfx/ots/src/gdef.cc
index 71c6fc592..71e1075e3 100644
--- a/gfx/ots/src/gdef.cc
+++ b/gfx/ots/src/gdef.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011-2017 The OTS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -11,68 +11,60 @@
 #include "gsub.h"
 #include "layout.h"
 #include "maxp.h"
+#include "variations.h"
 
 // GDEF - The Glyph Definition Table
 // http://www.microsoft.com/typography/otspec/gdef.htm
 
-#define TABLE_NAME "GDEF"
-
 namespace {
 
-// 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::Font *font, const uint8_t *data,
-                             size_t length, const uint16_t num_glyphs) {
-  return ots::ParseClassDefTable(font, data, length, num_glyphs,
-                                 kMaxGlyphClassDefValue);
-}
+const uint16_t kMaxCaretValueFormat = 3;
+
+}  // namespace
 
-bool ParseAttachListTable(ots::Font *font, const uint8_t *data,
-                          size_t length, const uint16_t num_glyphs) {
+namespace ots {
+
+bool OpenTypeGDEF::ParseAttachListTable(const uint8_t *data, size_t length) {
   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");
+    return Error("Failed to read gdef header");
   }
   const unsigned attach_points_end =
       2 * static_cast<unsigned>(glyph_count) + 4;
   if (attach_points_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE_MSG("Bad glyph count in gdef");
+    return Error("Bad glyph count in gdef");
   }
   if (offset_coverage == 0 || offset_coverage >= length ||
       offset_coverage < attach_points_end) {
-    return OTS_FAILURE_MSG("Bad coverage offset %d", offset_coverage);
+    return Error("Bad coverage offset %d", offset_coverage);
   }
-  if (glyph_count > num_glyphs) {
-    return OTS_FAILURE_MSG("Bad glyph count %u", glyph_count);
+  if (glyph_count > this->m_num_glyphs) {
+    return Error("Bad glyph count %u", glyph_count);
   }
 
   std::vector<uint16_t> attach_points;
   attach_points.resize(glyph_count);
   for (unsigned i = 0; i < glyph_count; ++i) {
     if (!subtable.ReadU16(&attach_points[i])) {
-      return OTS_FAILURE_MSG("Can't read attachment point %d", i);
+      return Error("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]);
+      return Error("Bad attachment point %d of %d", i, attach_points[i]);
     }
   }
 
   // Parse coverage table
-  if (!ots::ParseCoverageTable(font, data + offset_coverage,
-                               length - offset_coverage, num_glyphs)) {
-    return OTS_FAILURE_MSG("Bad coverage table");
+  if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage,
+                               length - offset_coverage, this->m_num_glyphs)) {
+    return Error("Bad coverage table");
   }
 
   // Parse attach point table
@@ -80,20 +72,20 @@ bool ParseAttachListTable(ots::Font *font, const uint8_t *data,
     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);
+      return Error("Can't read point count %d", i);
     }
     if (point_count == 0) {
-      return OTS_FAILURE_MSG("zero point count %d", i);
+      return Error("zero point count %d", i);
     }
     uint16_t last_point_index = 0;
     uint16_t point_index = 0;
     for (unsigned j = 0; j < point_count; ++j) {
       if (!subtable.ReadU16(&point_index)) {
-        return OTS_FAILURE_MSG("Can't read point index %d in point %d", j, i);
+        return Error("Can't read point index %d in point %d", j, i);
       }
       // Contour point indeces are in increasing numerical order
       if (last_point_index != 0 && last_point_index >= point_index) {
-        return OTS_FAILURE_MSG("bad contour indeces: %u >= %u",
+        return Error("bad contour indeces: %u >= %u",
                     last_point_index, point_index);
       }
       last_point_index = point_index;
@@ -102,43 +94,42 @@ bool ParseAttachListTable(ots::Font *font, const uint8_t *data,
   return true;
 }
 
-bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data,
-                            size_t length, const uint16_t num_glyphs) {
+bool OpenTypeGDEF::ParseLigCaretListTable(const uint8_t *data, size_t length) {
   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");
+    return Error("Can't read caret structure");
   }
   const unsigned lig_glyphs_end =
       2 * static_cast<unsigned>(lig_glyph_count) + 4;
   if (lig_glyphs_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE_MSG("Bad caret structure");
+    return Error("Bad caret structure");
   }
   if (offset_coverage == 0 || offset_coverage >= length ||
       offset_coverage < lig_glyphs_end) {
-    return OTS_FAILURE_MSG("Bad caret coverate offset %d", offset_coverage);
+    return Error("Bad caret coverate offset %d", offset_coverage);
   }
-  if (lig_glyph_count > num_glyphs) {
-    return OTS_FAILURE_MSG("bad ligature glyph count: %u", lig_glyph_count);
+  if (lig_glyph_count > this->m_num_glyphs) {
+    return Error("bad ligature glyph count: %u", lig_glyph_count);
   }
 
   std::vector<uint16_t> lig_glyphs;
   lig_glyphs.resize(lig_glyph_count);
   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);
+      return Error("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);
+      return Error("Bad ligature glyph location %d in glyph %d", lig_glyphs[i], i);
     }
   }
 
   // Parse coverage table
-  if (!ots::ParseCoverageTable(font, data + offset_coverage,
-                               length - offset_coverage, num_glyphs)) {
-    return OTS_FAILURE_MSG("Can't parse caret coverage table");
+  if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage,
+                               length - offset_coverage, this->m_num_glyphs)) {
+    return Error("Can't parse caret coverage table");
   }
 
   // Parse ligature glyph table
@@ -146,10 +137,10 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data,
     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);
+      return Error("Can't read caret count for glyph %d", i);
     }
     if (caret_count == 0) {
-      return OTS_FAILURE_MSG("bad caret value count: %u", caret_count);
+      return Error("bad caret value count: %u", caret_count);
     }
 
     std::vector<uint16_t> caret_value_offsets;
@@ -157,10 +148,10 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data,
     unsigned caret_value_offsets_end = 2 * static_cast<unsigned>(caret_count) + 2;
     for (unsigned j = 0; j < caret_count; ++j) {
       if (!subtable.ReadU16(&caret_value_offsets[j])) {
-        return OTS_FAILURE_MSG("Can't read caret offset %d for glyph %d", j, i);
+        return Error("Can't read caret offset %d for glyph %d", j, i);
       }
       if (caret_value_offsets[j] >= length || caret_value_offsets[j] < caret_value_offsets_end) {
-        return OTS_FAILURE_MSG("Bad caret offset %d for caret %d glyph %d", caret_value_offsets[j], j, i);
+        return Error("Bad caret offset %d for caret %d glyph %d", caret_value_offsets[j], j, i);
       }
     }
 
@@ -169,91 +160,93 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data,
       subtable.set_offset(lig_glyphs[i] + caret_value_offsets[j]);
       uint16_t caret_format = 0;
       if (!subtable.ReadU16(&caret_format)) {
-        return OTS_FAILURE_MSG("Can't read caret values table %d in glyph %d", j, i);
+        return Error("Can't read caret values table %d in glyph %d", j, i);
       }
-      // TODO(bashi): We only support caret value format 1 and 2 for now
-      // because there are no fonts which contain caret value format 3
-      // as far as we investigated.
       if (caret_format == 0 || caret_format > kMaxCaretValueFormat) {
-        return OTS_FAILURE_MSG("bad caret value format: %u", caret_format);
+        return Error("bad caret value format: %u", caret_format);
       }
       // 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 Error("Bad caret value table structure %d in glyph %d", j, i);
+      }
+      if (caret_format == 3) {
+        uint16_t offset_device = 0;
+        if (!subtable.ReadU16(&offset_device)) {
+          return Error("Can't read device offset for caret value %d "
+                       "in glyph %d", j, i);
+        }
+        uint16_t absolute_offset = lig_glyphs[i] + caret_value_offsets[j]
+                                   + offset_device;
+        if (offset_device == 0 || absolute_offset >= length) {
+          return Error("Bad device offset for caret value %d in glyph %d: %d",
+                       j, i, offset_device);
+        }
+        if (!ots::ParseDeviceTable(GetFont(), data + absolute_offset,
+                                   length - absolute_offset)) {
+          return Error("Bad device table for caret value %d in glyph %d",
+                       j, i, offset_device);
+        }
       }
     }
   }
   return true;
 }
 
-bool ParseMarkAttachClassDefTable(ots::Font *font, const uint8_t *data,
-                                  size_t length, const uint16_t num_glyphs) {
-  return ots::ParseClassDefTable(font, data, length, num_glyphs, kMaxClassDefValue);
-}
-
-bool ParseMarkGlyphSetsDefTable(ots::Font *font, const uint8_t *data,
-                                size_t length, const uint16_t num_glyphs) {
+bool OpenTypeGDEF::ParseMarkGlyphSetsDefTable(const uint8_t *data, size_t length) {
   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");
+    return Error("Can' read mark glyph table structure");
   }
   if (format != 1) {
-    return OTS_FAILURE_MSG("bad mark glyph set table format: %u", format);
+    return Error("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);
+    return Error("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);
+      return Error("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);
+      return Error("Bad coverage location %d for mark set %d", offset_coverage, i);
     }
-    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);
+    if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage,
+                                 length - offset_coverage, this->m_num_glyphs)) {
+      return Error("Failed to parse coverage table for mark set %d", i);
     }
   }
-  font->gdef->num_mark_glyph_sets = mark_set_count;
+  this->num_mark_glyph_sets = mark_set_count;
   return true;
 }
 
-}  // namespace
+bool OpenTypeGDEF::Parse(const uint8_t *data, size_t length) {
+  OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
+      GetFont()->GetTypedTable(OTS_TAG_MAXP));
 
-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");
+  if (!maxp) {
+    return Error("No maxp table in font, needed by GDEF");
   }
-  const uint16_t num_glyphs = font->maxp->num_glyphs;
+  this->m_num_glyphs = maxp->num_glyphs;
 
   Buffer table(data, length);
 
-  OpenTypeGDEF *gdef = new OpenTypeGDEF;
-  font->gdef = gdef;
-
-  uint32_t version = 0;
-  if (!table.ReadU32(&version)) {
-    return OTS_FAILURE_MSG("Incomplete table");
+  uint16_t version_major = 0, version_minor = 0;
+  if (!table.ReadU16(&version_major) ||
+      !table.ReadU16(&version_minor)) {
+    return Error("Incomplete table");
   }
-  if (version < 0x00010000 || version == 0x00010001) {
-    return OTS_FAILURE_MSG("Bad version");
-  }
-
-  if (version >= 0x00010002) {
-    gdef->version_2 = true;
+  if (version_major != 1 || version_minor == 1) { // there is no v1.1
+    return Error("Bad version");
   }
 
   uint16_t offset_glyph_class_def = 0;
@@ -264,110 +257,108 @@ bool ots_gdef_parse(Font *font, const uint8_t *data, size_t length) {
       !table.ReadU16(&offset_attach_list) ||
       !table.ReadU16(&offset_lig_caret_list) ||
       !table.ReadU16(&offset_mark_attach_class_def)) {
-    return OTS_FAILURE_MSG("Incomplete table");
+    return Error("Incomplete table");
   }
   uint16_t offset_mark_glyph_sets_def = 0;
-  if (gdef->version_2) {
+  if (version_minor >= 2) {
     if (!table.ReadU16(&offset_mark_glyph_sets_def)) {
-      return OTS_FAILURE_MSG("Incomplete table");
+      return Error("Incomplete table");
+    }
+  }
+  uint32_t item_var_store_offset = 0;
+  if (version_minor >= 3) {
+    if (!table.ReadU32(&item_var_store_offset)) {
+      return Error("Incomplete table");
     }
   }
 
   unsigned gdef_header_end = 4 + 4 * 2;
-  if (gdef->version_2)
+  if (version_minor >= 2)
     gdef_header_end += 2;
+  if (version_minor >= 3)
+    gdef_header_end += 4;
 
   // Parse subtables
   if (offset_glyph_class_def) {
     if (offset_glyph_class_def >= length ||
         offset_glyph_class_def < gdef_header_end) {
-      return OTS_FAILURE_MSG("Invalid offset to glyph classes");
+      return Error("Invalid offset to glyph classes");
     }
-    if (!ParseGlyphClassDefTable(font, data + offset_glyph_class_def,
+    if (!ots::ParseClassDefTable(GetFont(), data + offset_glyph_class_def,
                                  length - offset_glyph_class_def,
-                                 num_glyphs)) {
-      return OTS_FAILURE_MSG("Invalid glyph classes");
+                                 this->m_num_glyphs, kMaxGlyphClassDefValue)) {
+      return Error("Invalid glyph classes");
     }
-    gdef->has_glyph_class_def = true;
   }
 
   if (offset_attach_list) {
     if (offset_attach_list >= length ||
         offset_attach_list < gdef_header_end) {
-      return OTS_FAILURE_MSG("Invalid offset to attachment list");
+      return Error("Invalid offset to attachment list");
     }
-    if (!ParseAttachListTable(font, data + offset_attach_list,
-                              length - offset_attach_list,
-                              num_glyphs)) {
-      return OTS_FAILURE_MSG("Invalid attachment list");
+    if (!ParseAttachListTable(data + offset_attach_list,
+                              length - offset_attach_list)) {
+      return Error("Invalid attachment list");
     }
   }
 
   if (offset_lig_caret_list) {
     if (offset_lig_caret_list >= length ||
         offset_lig_caret_list < gdef_header_end) {
-      return OTS_FAILURE_MSG("Invalid offset to ligature caret list");
+      return Error("Invalid offset to ligature caret list");
     }
-    if (!ParseLigCaretListTable(font, data + offset_lig_caret_list,
-                              length - offset_lig_caret_list,
-                              num_glyphs)) {
-      return OTS_FAILURE_MSG("Invalid ligature caret list");
+    if (!ParseLigCaretListTable(data + offset_lig_caret_list,
+                                length - offset_lig_caret_list)) {
+      return Error("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");
+      return Error("Invalid offset to mark attachment list");
     }
-    if (!ParseMarkAttachClassDefTable(font,
-                                      data + offset_mark_attach_class_def,
-                                      length - offset_mark_attach_class_def,
-                                      num_glyphs)) {
-      return OTS_FAILURE_MSG("Invalid mark attachment list");
+    if (!ots::ParseClassDefTable(GetFont(),
+                                 data + offset_mark_attach_class_def,
+                                 length - offset_mark_attach_class_def,
+                                 this->m_num_glyphs, kMaxClassDefValue)) {
+      return Error("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");
+      return Error("invalid offset to mark glyph sets");
     }
-    if (!ParseMarkGlyphSetsDefTable(font,
-                                    data + offset_mark_glyph_sets_def,
-                                    length - offset_mark_glyph_sets_def,
-                                    num_glyphs)) {
-      return OTS_FAILURE_MSG("Invalid mark glyph sets");
+    if (!ParseMarkGlyphSetsDefTable(data + offset_mark_glyph_sets_def,
+                                    length - offset_mark_glyph_sets_def)) {
+      return Error("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;
-}
 
-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");
+  if (item_var_store_offset) {
+    if (item_var_store_offset >= length ||
+        item_var_store_offset < gdef_header_end) {
+      return Error("invalid offset to item variation store");
+    }
+    if (!ParseItemVariationStore(GetFont(), data + item_var_store_offset,
+                                 length - item_var_store_offset)) {
+      return Error("Invalid item variation store");
+    }
   }
 
+  this->m_data = data;
+  this->m_length = length;
   return true;
 }
 
-void ots_gdef_reuse(Font *font, Font *other) {
-  font->gdef = other->gdef;
-  font->gdef_reused = true;
-}
+bool OpenTypeGDEF::Serialize(OTSStream *out) {
+  if (!out->Write(this->m_data, this->m_length)) {
+    return Error("Failed to write table");
+  }
 
-void ots_gdef_free(Font *font) {
-  delete font->gdef;
+  return true;
 }
 
 }  // namespace ots
-
-#undef TABLE_NAME