Update OTS to revision 6d2e08b

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 27 matching lines @@
 
 const size_t kSfntHeaderSize = 12;
 const size_t kSfntEntrySize = 16;
 const size_t kCheckSumAdjustmentOffset = 8;
 
 const size_t kEndPtsOfContoursOffset = 10;
 const size_t kCompositeGlyphBegin = 10;
 
 // Note that the byte order is big-endian, not the same as ots.cc
 #define TAG(a, b, c, d) ((a << 24) | (b << 16) | (c << 8) | d)
-#define CHR(t)           (t >> 24),  (t >> 16),  (t >> 8), (t >> 0)
+#define UNTAG(t)         (t >> 24),  (t >> 16),  (t >> 8), (t >> 0)
 
 const unsigned int kWoff2FlagsTransform = 1 << 5;
 
 const uint32_t kKnownTags[] = {
   TAG('c', 'm', 'a', 'p'),  // 0
   TAG('h', 'e', 'a', 'd'),  // 1
   TAG('h', 'h', 'e', 'a'),  // 2
   TAG('h', 'm', 't', 'x'),  // 3
   TAG('m', 'a', 'x', 'p'),  // 4
   TAG('n', 'a', 'm', 'e'),  // 5
@@ skipping 706 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 Woff2Uncompress(uint8_t* dst_buf, size_t dst_size,
-    const uint8_t* src_buf, size_t src_size) {
-  size_t uncompressed_size = dst_size;
-  int ok = BrotliDecompressBuffer(src_size, src_buf,
-                                  &uncompressed_size, dst_buf);
-  if (!ok || uncompressed_size != dst_size) {
-    return OTS_FAILURE();
-  }
-  return true;
-}
-
 bool ReadTableDirectory(ots::OpenTypeFile* file,
     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) {
       if (!buffer->ReadU32(&tag)) {
         return OTS_FAILURE_MSG("Failed to read the tag of table directory entry %d", i);
       }
     } else {
       tag = kKnownTags[flag_byte & 0x3f];
     }
     // Bits 6 and 7 are reserved and must be 0.
     if ((flag_byte & 0xc0) != 0) {
       return OTS_FAILURE_MSG("Bits 6 and 7 are not 0 for table directory entry %d", i);
     }
     uint32_t flags = 0;
     // Always transform the glyf and loca tables
     if (tag == TAG('g', 'l', 'y', 'f') ||
         tag == TAG('l', 'o', 'c', 'a')) {
       flags |= kWoff2FlagsTransform;
     }
     uint32_t dst_length;
     if (!ReadBase128(buffer, &dst_length)) {
-      return OTS_FAILURE_MSG("Failed to read 'origLength' for table '%c%c%c%c'", CHR(tag));
+      return OTS_FAILURE_MSG("Failed to read 'origLength' for table '%c%c%c%c'", UNTAG(tag));
     }
     uint32_t transform_length = dst_length;
     if ((flags & kWoff2FlagsTransform) != 0) {
       if (!ReadBase128(buffer, &transform_length)) {
-        return OTS_FAILURE_MSG("Failed to read 'transformLength' for table '%c%c%c%c'", CHR(tag));
+        return OTS_FAILURE_MSG("Failed to read 'transformLength' for table '%c%c%c%c'", UNTAG(tag));
+      }
+
+      if (tag == TAG('l', 'o', 'c', 'a') && transform_length != 0) {
+        return OTS_FAILURE_MSG("The 'transformLength' of 'loca' table must be zero: %d", transform_length);
       }
     }
     // Disallow huge numbers (> 1GB) for sanity.
     if (transform_length > 1024 * 1024 * 1024 ||
         dst_length > 1024 * 1024 * 1024) {
       return OTS_FAILURE_MSG("'origLength' or 'transformLength' > 1GB");
     }
     table->tag = tag;
     table->flags = flags;
     table->transform_length = transform_length;
@@ skipping 182 matching lines @@
   for (uint16_t i = 0; i < num_tables; ++i) {
     total_size += tables.at(i).transform_length;
     if (total_size > std::numeric_limits<uint32_t>::max()) {
       return OTS_FAILURE();
     }
   }
   // Enforce same 30M limit on uncompressed tables as OTS
   if (total_size > 30 * 1024 * 1024) {
     return OTS_FAILURE();
   }
-  const size_t total_size_size_t = static_cast<size_t>(total_size);
-  uncompressed_buf.resize(total_size_size_t);
-  const uint8_t* src_buf = data + compressed_offset;
-  if (!Woff2Uncompress(&uncompressed_buf[0], total_size_size_t,
-      src_buf, compressed_length)) {
+  size_t uncompressed_size = static_cast<size_t>(total_size);
+  uncompressed_buf.resize(uncompressed_size);
+  const uint8_t* compressed_buf = data + compressed_offset;
+  if (!BrotliDecompressBuffer(compressed_length, compressed_buf,
+                              &uncompressed_size, &uncompressed_buf[0])) {
     return OTS_FAILURE_MSG("Failed to uncompress font data");
   }
+  if (uncompressed_size != static_cast<size_t>(total_size)) {
+    return OTS_FAILURE_MSG("Decompressed font data size does not match the sum of 'origLength' and 'transformLength'");
+  }
   transform_buf = &uncompressed_buf[0];
 
   for (uint16_t i = 0; i < num_tables; ++i) {
     const Table* table = &tables.at(i);
     uint32_t flags = table->flags;
     size_t transform_length = table->transform_length;
 
     if ((flags & kWoff2FlagsTransform) == 0) {
       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,
             transform_buf, transform_length, result, result_length)) {
-        return OTS_FAILURE_MSG("Failed to reconstruct '%c%c%c%c' table", CHR(table->tag));
+        return OTS_FAILURE_MSG("Failed to reconstruct '%c%c%c%c' table", 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