Update OTS to revision a7a3b94

third_party/ots/src/cff.cc

 // Copyright (c) 2012 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 "cff.h"
 
 #include <cstring>
 #include <utility>
 #include <vector>
 
@@ skipping 880 matching lines @@
       }
     }
   }
   return true;
 }
 
 }  // namespace
 
 namespace ots {
 
-bool ots_cff_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
+bool ots_cff_parse(Font *font, const uint8_t *data, size_t length) {
   Buffer table(data, length);
 
-  file->cff = new OpenTypeCFF;
-  file->cff->data = data;
-  file->cff->length = length;
-  file->cff->font_dict_length = 0;
-  file->cff->local_subrs = NULL;
+  font->cff = new OpenTypeCFF;
+  font->cff->data = data;
+  font->cff->length = length;
+  font->cff->font_dict_length = 0;
+  font->cff->local_subrs = NULL;
 
   // parse "6. Header" in the Adobe Compact Font Format Specification
   uint8_t major = 0;
   uint8_t minor = 0;
   uint8_t hdr_size = 0;
   uint8_t off_size = 0;
   if (!table.ReadU8(&major)) {
     return OTS_FAILURE();
   }
   if (!table.ReadU8(&minor)) {
@@ skipping 17 matching lines @@
   if (hdr_size >= length) {
     return OTS_FAILURE();
   }
 
   // parse "7. Name INDEX"
   table.set_offset(hdr_size);
   CFFIndex name_index;
   if (!ParseIndex(&table, &name_index)) {
     return OTS_FAILURE();
   }
-  if (!ParseNameData(&table, name_index, &(file->cff->name))) {
+  if (!ParseNameData(&table, name_index, &(font->cff->name))) {
     return OTS_FAILURE();
   }
 
   // parse "8. Top DICT INDEX"
   table.set_offset(name_index.offset_to_next);
   CFFIndex top_dict_index;
   if (!ParseIndex(&table, &top_dict_index)) {
     return OTS_FAILURE();
   }
   if (name_index.count != top_dict_index.count) {
     return OTS_FAILURE();
   }
 
   // parse "10. String INDEX"
   table.set_offset(top_dict_index.offset_to_next);
   CFFIndex string_index;
   if (!ParseIndex(&table, &string_index)) {
     return OTS_FAILURE();
   }
   if (string_index.count >= 65000 - kNStdString) {
     return OTS_FAILURE();
   }
 
-  const uint16_t num_glyphs = file->maxp->num_glyphs;
+  const uint16_t num_glyphs = font->maxp->num_glyphs;
   const size_t sid_max = string_index.count + kNStdString;
   // string_index.count == 0 is allowed.
 
   // parse "9. Top DICT Data"
   if (!ParseDictData(data, length, top_dict_index,
                      num_glyphs, sid_max,
-                     DICT_DATA_TOPLEVEL, file->cff)) {
+                     DICT_DATA_TOPLEVEL, font->cff)) {
     return OTS_FAILURE();
   }
 
   // parse "16. Global Subrs INDEX"
   table.set_offset(string_index.offset_to_next);
   CFFIndex global_subrs_index;
   if (!ParseIndex(&table, &global_subrs_index)) {
     return OTS_FAILURE();
   }
 
   // Check if all fd_index in FDSelect are valid.
   std::map<uint16_t, uint8_t>::const_iterator iter;
-  std::map<uint16_t, uint8_t>::const_iterator end = file->cff->fd_select.end();
-  for (iter = file->cff->fd_select.begin(); iter != end; ++iter) {
-    if (iter->second >= file->cff->font_dict_length) {
+  std::map<uint16_t, uint8_t>::const_iterator end = font->cff->fd_select.end();
+  for (iter = font->cff->fd_select.begin(); iter != end; ++iter) {
+    if (iter->second >= font->cff->font_dict_length) {
       return OTS_FAILURE();
     }
   }
 
   // Check if all charstrings (font hinting code for each glyph) are valid.
-  for (size_t i = 0; i < file->cff->char_strings_array.size(); ++i) {
-    if (!ValidateType2CharStringIndex(file,
-                                      *(file->cff->char_strings_array.at(i)),
+  for (size_t i = 0; i < font->cff->char_strings_array.size(); ++i) {
+    if (!ValidateType2CharStringIndex(font,
+                                      *(font->cff->char_strings_array.at(i)),
                                       global_subrs_index,
-                                      file->cff->fd_select,
-                                      file->cff->local_subrs_per_font,
-                                      file->cff->local_subrs,
+                                      font->cff->fd_select,
+                                      font->cff->local_subrs_per_font,
+                                      font->cff->local_subrs,
                                       &table)) {
       return OTS_FAILURE_MSG("Failed validating charstring set %d", (int) i);
     }
   }
 
   return true;
 }
 
-bool ots_cff_should_serialise(OpenTypeFile *file) {
-  return file->cff != NULL;
+bool ots_cff_should_serialise(Font *font) {
+  return font->cff != NULL;
 }
 
-bool ots_cff_serialise(OTSStream *out, OpenTypeFile *file) {
+bool ots_cff_serialise(OTSStream *out, Font *font) {
   // TODO(yusukes): would be better to transcode the data,
   //                rather than simple memcpy.
-  if (!out->Write(file->cff->data, file->cff->length)) {
+  if (!out->Write(font->cff->data, font->cff->length)) {
     return OTS_FAILURE();
   }
   return true;
 }
 
-void ots_cff_free(OpenTypeFile *file) {
-  if (file->cff) {
-    for (size_t i = 0; i < file->cff->char_strings_array.size(); ++i) {
-      delete (file->cff->char_strings_array)[i];
+void ots_cff_reuse(Font *font, Font *other) {
+  font->cff = other->cff;
+  font->cff_reused = true;
+}
+
+void ots_cff_free(Font *font) {
+  if (font->cff) {
+    for (size_t i = 0; i < font->cff->char_strings_array.size(); ++i) {
+      delete (font->cff->char_strings_array)[i];
     }
-    for (size_t i = 0; i < file->cff->local_subrs_per_font.size(); ++i) {
-      delete (file->cff->local_subrs_per_font)[i];
+    for (size_t i = 0; i < font->cff->local_subrs_per_font.size(); ++i) {
+      delete (font->cff->local_subrs_per_font)[i];
     }
-    delete file->cff->local_subrs;
-    delete file->cff;
+    delete font->cff->local_subrs;
+    delete font->cff;
   }
 }
 
 }  // namespace ots
 
 #undef TABLE_NAME