Update woff2 to 2bc6acf

third_party/woff2/src/woff2_dec.cc

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 616 matching lines @@
 
 Table* FindTable(std::vector<Table*>* tables, uint32_t tag) {
   for (Table* table : *tables) {
     if (table->tag == tag) {
       return table;
     }
   }
   return NULL;
 }
 
-// This is linear search, but could be changed to binary because we
-// do have a guarantee that the tables are sorted by tag. But the total
-// cpu time is expected to be very small in any case.
-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[i].tag == tag) {
-      return &tables[i];
-    }
-  }
-  return NULL;
-}
-
-// https://www.microsoft.com/typography/otspec/maxp.htm
-bool ReadNumGlyphs(const Table* maxp_table,
-                   const uint8_t* dst, size_t dst_length,
-                   uint16_t* num_glyphs) {
-  if (PREDICT_FALSE(static_cast<uint64_t>(maxp_table->dst_offset +
-      maxp_table->dst_length) > dst_length)) {
-    return FONT_COMPRESSION_FAILURE();
-  }
-  Buffer buffer(dst + maxp_table->dst_offset, maxp_table->dst_length);
-  // Skip 4 to reach 'maxp' numGlyphs
-  if (PREDICT_FALSE(!buffer.Skip(4) || !buffer.ReadU16(num_glyphs))) {
-    return FONT_COMPRESSION_FAILURE();
-  }
-  return true;
-}
-
 // Get numberOfHMetrics, https://www.microsoft.com/typography/otspec/hhea.htm
 bool ReadNumHMetrics(const uint8_t* data, size_t data_size,
                      uint16_t* num_hmetrics) {
   // Skip 34 to reach 'hhea' numberOfHMetrics
   Buffer buffer(data, data_size);
   if (PREDICT_FALSE(!buffer.Skip(34) || !buffer.ReadU16(num_hmetrics))) {
     return FONT_COMPRESSION_FAILURE();
   }
   return true;
 }
 
-// x_min for glyph; https://www.microsoft.com/typography/otspec/glyf.htm
-bool ReadGlyphXMin(Buffer* glyf_buff, Buffer* loca_buff, int16_t loca_format,
-                   uint16_t index, int16_t* x_min) {
-  uint32_t offset1, offset2;
-  loca_buff->set_offset((loca_format == 0 ? 2 : 4) * index);
-  if (loca_format == 0) {
-    uint16_t tmp1, tmp2;
-    if (PREDICT_FALSE(!loca_buff->ReadU16(&tmp1) ||
-                      !loca_buff->ReadU16(&tmp2))) {
-      return FONT_COMPRESSION_FAILURE();
-    }
-    // https://www.microsoft.com/typography/otspec/loca.htm
-    // "The actual local offset divided by 2 is stored."
-    offset1 = tmp1 * 2;
-    offset2 = tmp2 * 2;
-  } else if (PREDICT_FALSE(!loca_buff->ReadU32(&offset1) ||
-                           !loca_buff->ReadU32(&offset2))) {
-    return FONT_COMPRESSION_FAILURE();
-  }
-
-  if (offset1 != offset2) {
-    glyf_buff->set_offset(offset1 + 2);
-    if (!glyf_buff->ReadS16(x_min)) {
-      return FONT_COMPRESSION_FAILURE();
-    }
-  } else {
-    *x_min = 0;
-  }
-  return true;
-}
-
 // http://dev.w3.org/webfonts/WOFF2/spec/Overview.html#hmtx_table_format
 bool ReconstructTransformedHmtx(const uint8_t* transformed_buf,
                                 size_t transformed_size,
                                 uint16_t num_glyphs,
                                 uint16_t num_hmetrics,
                                 const std::vector<int16_t>& x_mins,
                                 uint32_t* checksum,
                                 WOFF2Out* out) {
   Buffer hmtx_buff_in(transformed_buf, transformed_size);
 
@@ skipping 59 matching lines @@
   }
 
   *checksum = ComputeULongSum(&hmtx_table[0], hmtx_output_size);
   if (PREDICT_FALSE(!out->Write(&hmtx_table[0], hmtx_output_size))) {
     return FONT_COMPRESSION_FAILURE();
   }
 
   return true;
 }
 
-uint32_t ComputeChecksum(const Table* table, const uint8_t* dst) {
-  return ComputeULongSum(dst + table->dst_offset, table->dst_length);
-}
-
-const Table* FindTable(TtcFont ttc_font, const std::vector<Table>& tables,
-  uint32_t tag) {
-  for (const auto i : ttc_font.table_indices) {
-    if (tables[i].tag == tag) return &tables[i];
-  }
-  return NULL;
-}
-
 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 (PREDICT_FALSE(!ok || uncompressed_size != dst_size)) {
     return FONT_COMPRESSION_FAILURE();
   }
   return true;
 }
@@ skipping 546 matching lines @@
                                        hdr.uncompressed_size,
                                        &metadata, &hdr, i, out))) {
       return FONT_COMPRESSION_FAILURE();
     }
   }
 
   return true;
 }
 
 } // namespace woff2