Update OTS to revision a7a3b94

third_party/ots/src/woff2.cc

 // Copyright (c) 2013 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.
 
 // This is the implementation of decompression of the proposed WOFF Ultra
 // Condensed file format.
 
 #include <cassert>
 #include <cstdlib>
 #include <vector>
@@ skipping 164 matching lines @@
   }
 }
 
 bool ReadBase128(ots::Buffer* buf, uint32_t* value) {
   uint32_t result = 0;
   for (size_t i = 0; i < 5; ++i) {
     uint8_t code = 0;
     if (!buf->ReadU8(&code)) {
       return OTS_FAILURE();
     }
+    if (i == 0 && code == 0x80) {
+      return OTS_FAILURE();
+    }
     // If any of the top seven bits are set then we're about to overflow.
     if (result & 0xfe000000U) {
       return OTS_FAILURE();
     }
     result = (result << 7) | (code & 0x7f);
     if ((code & 0x80) == 0) {
       *value = result;
       return true;
     }
   }
@@ skipping 308 matching lines @@
     if (index_format) {
       offset = StoreU32(dst, offset, value);
     } else {
       offset = StoreU16(dst, offset, static_cast<uint16_t>(value >> 1));
     }
   }
   return true;
 }
 
 // Reconstruct entire glyf table based on transformed original
-bool ReconstructGlyf(ots::OpenTypeFile* file,
+bool ReconstructGlyf(ots::Font *font,
     const uint8_t* data, size_t data_size,
     uint8_t* dst, size_t dst_size,
     uint8_t* loca_buf, size_t loca_size) {
   static const int kNumSubStreams = 7;
   ots::Buffer buffer(data, data_size);
   uint32_t version;
   std::vector<std::pair<const uint8_t*, size_t> > substreams(kNumSubStreams);
 
   if (!buffer.ReadU32(&version)) {
     return OTS_FAILURE_MSG("Failed to read 'version' of transformed 'glyf' table");
@@ skipping 29 matching lines @@
   ots::Buffer composite_stream(substreams.at(4).first, substreams.at(4).second);
   ots::Buffer bbox_stream(substreams.at(5).first, substreams.at(5).second);
   ots::Buffer instruction_stream(substreams.at(6).first,
                                  substreams.at(6).second);
 
   std::vector<uint32_t> loca_values;
   loca_values.reserve(num_glyphs + 1);
   std::vector<uint16_t> n_points_vec;
   std::vector<Point> points;
   uint32_t loca_offset = 0;
+  const uint8_t* bbox_bitmap = bbox_stream.buffer();
   for (unsigned int i = 0; i < num_glyphs; ++i) {
     size_t glyph_size = 0;
     uint16_t n_contours = 0;
     if (!n_contour_stream.ReadU16(&n_contours)) {
       return OTS_FAILURE_MSG("Filed to read 'numberOfContours' of glyph %d from transformed 'glyf' table", i);
     }
     uint8_t* glyf_dst = dst + loca_offset;
     size_t glyf_dst_size = dst_size - loca_offset;
     if (n_contours == 0xffff) {
       // composite glyph
+      if (!(bbox_bitmap[i >> 3] & (0x80 >> (i & 7)))) {
+        return OTS_FAILURE_MSG("Composite glyph %d without bbox", i);
+      }
       bool have_instructions = false;
       uint16_t instruction_size = 0;
       if (!ProcessComposite(&composite_stream, glyf_dst, glyf_dst_size,
             &glyph_size, &have_instructions)) {
         return OTS_FAILURE_MSG("Filed to process composite glyph %d from transformed 'glyf' table", i);
       }
       if (have_instructions) {
         if (!Read255UShort(&glyph_stream, &instruction_size)) {
           return OTS_FAILURE_MSG("Failed to read 'instructionLength' of glyph %d from transformed 'glyf' table", i);
         }
@@ skipping 107 matching lines @@
 const Table* FindTable(const std::vector<Table>& tables, uint32_t tag) {
   size_t n_tables = tables.size();
   for (size_t i = 0; i < n_tables; ++i) {
     if (tables.at(i).tag == tag) {
       return &tables.at(i);
     }
   }
   return NULL;
 }
 
-bool ReconstructTransformed(ots::OpenTypeFile* file,
+bool ReconstructTransformed(ots::Font *font,
     const std::vector<Table>& tables, uint32_t tag,
     const uint8_t* transformed_buf, size_t transformed_size,
     uint8_t* dst, size_t dst_length) {
   if (tag == OTS_TAG('g','l','y','f')) {
     const Table* glyf_table = FindTable(tables, tag);
     const Table* loca_table = FindTable(tables, OTS_TAG('l','o','c','a'));
     if (glyf_table == NULL || loca_table == NULL) {
       return OTS_FAILURE();
     }
     if (static_cast<uint64_t>(glyf_table->dst_offset) + glyf_table->dst_length >
         dst_length) {
       return OTS_FAILURE();
     }
     if (static_cast<uint64_t>(loca_table->dst_offset) + loca_table->dst_length >
         dst_length) {
       return OTS_FAILURE();
     }
-    return ReconstructGlyf(file, transformed_buf, transformed_size,
+    return ReconstructGlyf(font, transformed_buf, transformed_size,
         dst + glyf_table->dst_offset, glyf_table->dst_length,
         dst + loca_table->dst_offset, loca_table->dst_length);
   } else if (tag == OTS_TAG('l','o','c','a')) {
     // processing was already done by glyf table, but validate
     if (!FindTable(tables, OTS_TAG('g','l','y','f'))) {
       return OTS_FAILURE();
     }
   } else {
     // transform for the tag is not known
     return OTS_FAILURE();
@@ skipping 32 matching lines @@
     StoreU32(dst, kSfntHeaderSize + i * kSfntEntrySize + 4, checksum);
     file_checksum += checksum;  // The addition is mod 2^32
   }
   file_checksum += ComputeChecksum(dst,
       kSfntHeaderSize + kSfntEntrySize * n_tables);
   uint32_t checksum_adjustment = 0xb1b0afba - file_checksum;
   StoreU32(dst, adjustment_offset, checksum_adjustment);
   return true;
 }
 
-bool ReadTableDirectory(ots::OpenTypeFile* file,
+bool ReadTableDirectory(ots::Font *font,
     ots::Buffer* buffer, std::vector<Table>* tables,
     size_t num_tables) {
   for (size_t i = 0; i < num_tables; ++i) {
     Table* table = &tables->at(i);
     uint8_t flag_byte;
     if (!buffer->ReadU8(&flag_byte)) {
       return OTS_FAILURE_MSG("Failed to read the flags of table directory entry %d", i);
     }
     uint32_t tag;
     if ((flag_byte & 0x3f) == 0x3f) {
@@ skipping 48 matching lines @@
   ots::Buffer file(data, length);
   uint32_t total_length;
 
   if (!file.Skip(16) ||
       !file.ReadU32(&total_length)) {
     return 0;
   }
   return total_length;
 }
 
-bool ConvertWOFF2ToSFNT(ots::OpenTypeFile* file,
+bool ConvertWOFF2ToSFNT(ots::Font *font,
                         uint8_t* result, size_t result_length,
                         const uint8_t* data, size_t length) {
   static const uint32_t kWoff2Signature = 0x774f4632;  // "wOF2"
   ots::Buffer buffer(data, length);
 
   uint32_t signature;
   uint32_t flavor = 0;
   if (!buffer.ReadU32(&signature) || signature != kWoff2Signature ||
       !buffer.ReadU32(&flavor)) {
     return OTS_FAILURE_MSG("Failed to read 'signature' or 'flavor', or not WOFF2 signature");
   }
 
-  if (!IsValidVersionTag(ntohl(flavor))) {
+  if (!IsValidVersionTag(flavor)) {
     return OTS_FAILURE_MSG("Invalid 'flavor'");
   }
 
   uint32_t reported_length;
   if (!buffer.ReadU32(&reported_length) || length != reported_length) {
     return OTS_FAILURE_MSG("Failed to read 'length' or it does not match the actual file size");
   }
   uint16_t num_tables;
   if (!buffer.ReadU16(&num_tables) || !num_tables) {
     return OTS_FAILURE_MSG("Failed to read 'numTables'");
@@ skipping 45 matching lines @@
       !buffer.ReadU32(&priv_length)) {
     return OTS_FAILURE_MSG("Failed to read header private block fields");
   }
   if (priv_offset) {
     if (priv_offset >= length || length - priv_offset < priv_length) {
       return OTS_FAILURE_MSG("Invalid private block offset or length");
     }
   }
 
   std::vector<Table> tables(num_tables);
-  if (!ReadTableDirectory(file, &buffer, &tables, num_tables)) {
+  if (!ReadTableDirectory(font, &buffer, &tables, num_tables)) {
     return OTS_FAILURE_MSG("Failed to read table directory");
   }
   uint64_t compressed_offset = buffer.offset();
   if (compressed_offset > std::numeric_limits<uint32_t>::max()) {
     return OTS_FAILURE();
   }
   uint64_t dst_offset = kSfntHeaderSize +
       kSfntEntrySize * static_cast<uint64_t>(num_tables);
   for (uint16_t i = 0; i < num_tables; ++i) {
     Table* table = &tables.at(i);
@@ skipping 100 matching lines @@
       if (transform_length != table->dst_length) {
         return OTS_FAILURE();
       }
       if (static_cast<uint64_t>(table->dst_offset) + transform_length >
           result_length) {
         return OTS_FAILURE();
       }
       std::memcpy(result + table->dst_offset, transform_buf,
           transform_length);
     } else {
-      if (!ReconstructTransformed(file, tables, table->tag,
+      if (!ReconstructTransformed(font, tables, table->tag,
             transform_buf, transform_length, result, result_length)) {
         return OTS_FAILURE_MSG("Failed to reconstruct '%c%c%c%c' table", OTS_UNTAG(table->tag));
       }
     }
 
     transform_buf += transform_length;
     if (transform_buf > &uncompressed_buf[0] + uncompressed_buf.size()) {
       return OTS_FAILURE();
     }
   }
 
   return FixChecksums(sorted_tables, result);
 }
 
 }  // namespace ots
 
 #undef TABLE_NAME