Update OTS to revision 99a3b7f

third_party/ots/src/ots.cc

 // Copyright (c) 2009 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 "ots.h"
 
 #include <sys/types.h>
 #include <zlib.h>
 
 #include <algorithm>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <map>
 #include <vector>
 
-#include "woff2.h"
+#include "third_party/woff2/src/woff2_dec.h"
 
 // The OpenType Font File
 // http://www.microsoft.com/typography/otspec/cmap.htm
 
 namespace {
 
 // Generate a message with or without a table tag, when 'header' is the OpenTypeFile pointer
 #define OTS_FAILURE_MSG_TAG(msg_,tag_) OTS_FAILURE_MSG_TAG_(header, msg_, tag_)
 #define OTS_FAILURE_MSG_HDR(msg_)      OTS_FAILURE_MSG_(header, msg_)
 #define OTS_WARNING_MSG_HDR(msg_)      OTS_WARNING_MSG_(header, msg_)
@@ skipping 36 matching lines @@
  private:
   std::vector<uint8_t*> hunks_;
 };
 
 const struct {
   uint32_t tag;
   bool (*parse)(ots::Font *font, const uint8_t *data, size_t length);
   bool (*serialise)(ots::OTSStream *out, ots::Font *font);
   bool (*should_serialise)(ots::Font *font);
   void (*reuse)(ots::Font *font, ots::Font *other);
-  void (*free)(ots::Font *font);
   bool required;
 } table_parsers[] = {
   { OTS_TAG('m','a','x','p'), ots::ots_maxp_parse, ots::ots_maxp_serialise,
-    ots::ots_maxp_should_serialise, ots::ots_maxp_reuse, ots::ots_maxp_free,
-    true },
+    ots::ots_maxp_should_serialise, ots::ots_maxp_reuse, true },
   { OTS_TAG('h','e','a','d'), ots::ots_head_parse, ots::ots_head_serialise,
-    ots::ots_head_should_serialise, ots::ots_head_reuse, ots::ots_head_free,
-    true },
+    ots::ots_head_should_serialise, ots::ots_head_reuse, true },
   { OTS_TAG('O','S','/','2'), ots::ots_os2_parse, ots::ots_os2_serialise,
-    ots::ots_os2_should_serialise, ots::ots_os2_reuse, ots::ots_os2_free,
-    true },
+    ots::ots_os2_should_serialise, ots::ots_os2_reuse, true },
   { OTS_TAG('c','m','a','p'), ots::ots_cmap_parse, ots::ots_cmap_serialise,
-    ots::ots_cmap_should_serialise, ots::ots_cmap_reuse, ots::ots_cmap_free,
-    true },
+    ots::ots_cmap_should_serialise, ots::ots_cmap_reuse, true },
   { OTS_TAG('h','h','e','a'), ots::ots_hhea_parse, ots::ots_hhea_serialise,
-    ots::ots_hhea_should_serialise, ots::ots_hhea_reuse, ots::ots_hhea_free,
-    true },
+    ots::ots_hhea_should_serialise, ots::ots_hhea_reuse, true },
   { OTS_TAG('h','m','t','x'), ots::ots_hmtx_parse, ots::ots_hmtx_serialise,
-    ots::ots_hmtx_should_serialise, ots::ots_hmtx_reuse, ots::ots_hmtx_free,
-    true },
+    ots::ots_hmtx_should_serialise, ots::ots_hmtx_reuse, true },
   { OTS_TAG('n','a','m','e'), ots::ots_name_parse, ots::ots_name_serialise,
-    ots::ots_name_should_serialise, ots::ots_name_reuse, ots::ots_name_free,
-    true },
+    ots::ots_name_should_serialise, ots::ots_name_reuse, true },
   { OTS_TAG('p','o','s','t'), ots::ots_post_parse, ots::ots_post_serialise,
-    ots::ots_post_should_serialise, ots::ots_post_reuse, ots::ots_post_free,
-    true },
+    ots::ots_post_should_serialise, ots::ots_post_reuse, true },
   { OTS_TAG('l','o','c','a'), ots::ots_loca_parse, ots::ots_loca_serialise,
-    ots::ots_loca_should_serialise, ots::ots_loca_reuse, ots::ots_loca_free,
-    false },
+    ots::ots_loca_should_serialise, ots::ots_loca_reuse, false },
   { OTS_TAG('g','l','y','f'), ots::ots_glyf_parse, ots::ots_glyf_serialise,
-    ots::ots_glyf_should_serialise, ots::ots_glyf_reuse, ots::ots_glyf_free,
-    false },
+    ots::ots_glyf_should_serialise, ots::ots_glyf_reuse, false },
   { OTS_TAG('C','F','F',' '), ots::ots_cff_parse, ots::ots_cff_serialise,
-    ots::ots_cff_should_serialise, ots::ots_cff_reuse, ots::ots_cff_free,
-    false },
+    ots::ots_cff_should_serialise, ots::ots_cff_reuse, false },
   { OTS_TAG('V','D','M','X'), ots::ots_vdmx_parse, ots::ots_vdmx_serialise,
-    ots::ots_vdmx_should_serialise, ots::ots_vdmx_reuse, ots::ots_vdmx_free,
-    false },
+    ots::ots_vdmx_should_serialise, ots::ots_vdmx_reuse, false },
   { OTS_TAG('h','d','m','x'), ots::ots_hdmx_parse, ots::ots_hdmx_serialise,
-    ots::ots_hdmx_should_serialise, ots::ots_hdmx_reuse, ots::ots_hdmx_free,
-    false },
+    ots::ots_hdmx_should_serialise, ots::ots_hdmx_reuse, false },
   { OTS_TAG('g','a','s','p'), ots::ots_gasp_parse, ots::ots_gasp_serialise,
-    ots::ots_gasp_should_serialise, ots::ots_gasp_reuse, ots::ots_gasp_free,
-    false },
+    ots::ots_gasp_should_serialise, ots::ots_gasp_reuse, false },
   { OTS_TAG('c','v','t',' '), ots::ots_cvt_parse, ots::ots_cvt_serialise,
-    ots::ots_cvt_should_serialise, ots::ots_cvt_reuse, ots::ots_cvt_free,
-    false },
+    ots::ots_cvt_should_serialise, ots::ots_cvt_reuse, false },
   { OTS_TAG('f','p','g','m'), ots::ots_fpgm_parse, ots::ots_fpgm_serialise,
-    ots::ots_fpgm_should_serialise, ots::ots_fpgm_reuse, ots::ots_fpgm_free,
-    false },
+    ots::ots_fpgm_should_serialise, ots::ots_fpgm_reuse, false },
   { OTS_TAG('p','r','e','p'), ots::ots_prep_parse, ots::ots_prep_serialise,
-    ots::ots_prep_should_serialise, ots::ots_prep_reuse, ots::ots_prep_free,
-    false },
+    ots::ots_prep_should_serialise, ots::ots_prep_reuse, false },
   { OTS_TAG('L','T','S','H'), ots::ots_ltsh_parse, ots::ots_ltsh_serialise,
-    ots::ots_ltsh_should_serialise, ots::ots_ltsh_reuse, ots::ots_ltsh_free,
-    false },
+    ots::ots_ltsh_should_serialise, ots::ots_ltsh_reuse, false },
   { OTS_TAG('V','O','R','G'), ots::ots_vorg_parse, ots::ots_vorg_serialise,
-    ots::ots_vorg_should_serialise, ots::ots_vorg_reuse, ots::ots_vorg_free,
-    false },
+    ots::ots_vorg_should_serialise, ots::ots_vorg_reuse, false },
   { OTS_TAG('k','e','r','n'), ots::ots_kern_parse, ots::ots_kern_serialise,
-    ots::ots_kern_should_serialise, ots::ots_kern_reuse, ots::ots_kern_free,
-    false },
+    ots::ots_kern_should_serialise, ots::ots_kern_reuse, false },
   // We need to parse GDEF table in advance of parsing GSUB/GPOS tables
   // because they could refer GDEF table.
   { OTS_TAG('G','D','E','F'), ots::ots_gdef_parse, ots::ots_gdef_serialise,
-    ots::ots_gdef_should_serialise, ots::ots_gdef_reuse, ots::ots_gdef_free,
-    false },
+    ots::ots_gdef_should_serialise, ots::ots_gdef_reuse, false },
   { OTS_TAG('G','P','O','S'), ots::ots_gpos_parse, ots::ots_gpos_serialise,
-    ots::ots_gpos_should_serialise, ots::ots_gpos_reuse, ots::ots_gpos_free,
-    false },
+    ots::ots_gpos_should_serialise, ots::ots_gpos_reuse, false },
   { OTS_TAG('G','S','U','B'), ots::ots_gsub_parse, ots::ots_gsub_serialise,
-    ots::ots_gsub_should_serialise, ots::ots_gsub_reuse, ots::ots_gsub_free,
-    false },
+    ots::ots_gsub_should_serialise, ots::ots_gsub_reuse, false },
   { OTS_TAG('v','h','e','a'), ots::ots_vhea_parse, ots::ots_vhea_serialise,
-    ots::ots_vhea_should_serialise, ots::ots_vhea_reuse, ots::ots_vhea_free,
-    false },
+    ots::ots_vhea_should_serialise, ots::ots_vhea_reuse, false },
   { OTS_TAG('v','m','t','x'), ots::ots_vmtx_parse, ots::ots_vmtx_serialise,
-    ots::ots_vmtx_should_serialise, ots::ots_vmtx_reuse, ots::ots_vmtx_free,
-    false },
+    ots::ots_vmtx_should_serialise, ots::ots_vmtx_reuse, false },
   { OTS_TAG('M','A','T','H'), ots::ots_math_parse, ots::ots_math_serialise,
-    ots::ots_math_should_serialise, ots::ots_math_reuse, ots::ots_math_free,
-    false },
-  { 0, NULL, NULL, NULL, NULL, NULL, false },
+    ots::ots_math_should_serialise, ots::ots_math_reuse, false },
+  { 0, NULL, NULL, NULL, NULL, false },
 };
 
 bool ProcessGeneric(ots::OpenTypeFile *header,
                     ots::Font *font,
                     uint32_t signature,
                     ots::OTSStream *output,
                     const uint8_t *data, size_t length,
                     const std::vector<OpenTypeTable>& tables,
                     ots::Buffer& file);
 
@@ skipping 186 matching lines @@
     return OTS_FAILURE_MSG_HDR("invalid WOFF marker");
   }
 
   if (!file.ReadU32(&font->version)) {
     return OTS_FAILURE_MSG_HDR("error reading version tag");
   }
   if (!ots::IsValidVersionTag(font->version)) {
     return OTS_FAILURE_MSG_HDR("invalid version tag");
   }
 
-  font->search_range = 0;
-  font->entry_selector = 0;
-  font->range_shift = 0;
-
   uint32_t reported_length;
   if (!file.ReadU32(&reported_length) || length != reported_length) {
     return OTS_FAILURE_MSG_HDR("incorrect file size in WOFF header");
   }
 
   if (!file.ReadU16(&font->num_tables) || !font->num_tables) {
     return OTS_FAILURE_MSG_HDR("error reading number of tables");
   }
 
   uint16_t reserved_value;
@@ skipping 110 matching lines @@
     }
   }
   if (block_end != ots::Round4(length)) {
     return OTS_FAILURE_MSG_HDR("File length mismatch (trailing junk?)");
   }
 
   return ProcessGeneric(header, font, woff_tag, output, data, length, tables, file);
 }
 
 bool ProcessWOFF2(ots::OpenTypeFile *header,
-                  ots::Font *font,
-                  ots::OTSStream *output, const uint8_t *data, size_t length) {
-  size_t decompressed_size = ots::ComputeWOFF2FinalSize(data, length);
+                  ots::OTSStream *output,
+                  const uint8_t *data,
+                  size_t length,
+                  uint32_t index) {
+  size_t decompressed_size = woff2::ComputeWOFF2FinalSize(data, length);
 
   if (decompressed_size == 0) {
     return OTS_FAILURE_MSG_HDR("Size of decompressed WOFF 2.0 is set to 0");
   }
   // decompressed font must be <= 30MB
   if (decompressed_size > 30 * 1024 * 1024) {
     return OTS_FAILURE_MSG_HDR("Size of decompressed WOFF 2.0 font exceeds 30MB");
   }
 
   std::vector<uint8_t> decompressed_buffer(decompressed_size);
-  if (!ots::ConvertWOFF2ToSFNT(font, &decompressed_buffer[0], decompressed_size,
-                               data, length)) {
+  if (!woff2::ConvertWOFF2ToTTF(&decompressed_buffer[0], decompressed_size,
+                                data, length)) {
     return OTS_FAILURE_MSG_HDR("Failed to convert WOFF 2.0 font to SFNT");
   }
-  return ProcessTTF(header, font, output, &decompressed_buffer[0], decompressed_size);
+
+  if (data[4] == 't' && data[5] == 't' && data[6] == 'c' && data[7] == 'f') {
+    return ProcessTTC(header, output, &decompressed_buffer[0], decompressed_size, index);
+  } else {
+    ots::Font font(header);
+    return ProcessTTF(header, &font, output, &decompressed_buffer[0], decompressed_size);
+  }
 }
 
 ots::TableAction GetTableAction(ots::OpenTypeFile *header, uint32_t tag) {
-  ots::TableAction action = ots::TABLE_ACTION_DEFAULT;
-
-  action = header->context->GetTableAction(htonl(tag));
+  ots::TableAction action = header->context->GetTableAction(tag);
 
   if (action == ots::TABLE_ACTION_DEFAULT) {
     action = ots::TABLE_ACTION_DROP;
 
     for (unsigned i = 0; ; ++i) {
       if (table_parsers[i].parse == NULL) break;
 
       if (table_parsers[i].tag == tag) {
         action = ots::TABLE_ACTION_SANITIZE;
         break;
       }
     }
   }
 
   assert(action != ots::TABLE_ACTION_DEFAULT); // Should never return this.
   return action;
 }
 
 bool GetTableData(const uint8_t *data,
-                  const OpenTypeTable table,
+                  const OpenTypeTable& table,
                   Arena *arena,
                   size_t *table_length,
                   const uint8_t **table_data) {
   if (table.uncompressed_length != table.length) {
     // Compressed table. Need to uncompress into memory first.
     *table_length = table.uncompressed_length;
     *table_data = (*arena).Allocate(*table_length);
     uLongf dest_len = *table_length;
     int r = uncompress((Bytef*) *table_data, &dest_len,
                        data + table.offset, table.length);
@@ skipping 132 matching lines @@
     if (ot == header->tables.end()) {
       const uint8_t* table_data;
       size_t table_length;
 
       if (!GetTableData(data, it->second, &arena, &table_length, &table_data)) {
         return OTS_FAILURE_MSG_TAG("uncompress failed", table_parsers[i].tag);
       }
 
       if (action == ots::TABLE_ACTION_SANITIZE &&
           !table_parsers[i].parse(font, table_data, table_length)) {
-        // TODO: parsers should generate specific messages detailing the failure;
-        // once those are all added, we won't need a generic failure message here
-        return OTS_FAILURE_MSG_TAG("failed to parse table", table_parsers[i].tag);
+        return OTS_FAILURE();
       }
     } else if (action == ots::TABLE_ACTION_SANITIZE) {
       table_parsers[i].reuse(font, ot->second.first);
     }
   }
 
   if (font->cff) {
     // font with PostScript glyph
     if (font->version != OTS_TAG('O','T','T','O')) {
       return OTS_FAILURE_MSG_HDR("wrong font version for PostScript glyph data");
@@ skipping 206 matching lines @@
   header.context = this;
 
   if (length < 4) {
     return OTS_FAILURE_MSG_(&header, "file less than 4 bytes");
   }
 
   bool result;
   if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == 'F') {
     result = ProcessWOFF(&header, &font, output, data, length);
   } else if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == '2') {
-    result = ProcessWOFF2(&header, &font, output, data, length);
+    result = ProcessWOFF2(&header, output, data, length, index);
   } else if (data[0] == 't' && data[1] == 't' && data[2] == 'c' && data[3] == 'f') {
     result = ProcessTTC(&header, output, data, length, index);
   } else {
     result = ProcessTTF(&header, &font, output, data, length);
   }
 
   return result;
 }
 
 }  // namespace ots