Update OTS to revision a7a3b94

third_party/ots/src/cmap.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 "cmap.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 43 matching lines @@
 //   0xE0100-0xE01EF (240 code points)
 const uint32_t kMongolianVSStart = 0x180B;
 const uint32_t kMongolianVSEnd = 0x180D;
 const uint32_t kVSStart = 0xFE00;
 const uint32_t kVSEnd = 0xFE0F;
 const uint32_t kIVSStart = 0xE0100;
 const uint32_t kIVSEnd = 0xE01EF;
 const uint32_t kUVSUpperLimit = 0xFFFFFF;
 
 // Parses Format 4 tables
-bool ParseFormat4(ots::OpenTypeFile *file, int platform, int encoding,
+bool ParseFormat4(ots::Font *font, int platform, int encoding,
               const uint8_t *data, size_t length, uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   // 0.3.4, 3.0.4 or 3.1.4 subtables are complex and, rather than expanding the
   // whole thing and recompacting it, we validate it and include it verbatim
   // in the output.
 
-  if (!file->os2) {
+  if (!font->os2) {
     return OTS_FAILURE_MSG("Required OS/2 table missing");
   }
 
   if (!subtable.Skip(4)) {
     return OTS_FAILURE_MSG("Can't read 4 bytes at start of cmap format 4 subtable");
   }
   uint16_t language = 0;
   if (!subtable.ReadU16(&language)) {
     return OTS_FAILURE_MSG("Can't read language");
   }
@@ skipping 105 matching lines @@
     // unsorted table...
     if (ranges[i].end_range <= ranges[i - 1].end_range) {
       return OTS_FAILURE_MSG("Out of order end range (%d <= %d)", ranges[i].end_range, ranges[i-1].end_range);
     }
     if (ranges[i].start_range <= ranges[i - 1].end_range) {
       return OTS_FAILURE_MSG("out of order start range (%d <= %d)", ranges[i].start_range, ranges[i-1].end_range);
     }
 
     // On many fonts, the value of {first, last}_char_index are incorrect.
     // Fix them.
-    if (file->os2->first_char_index != 0xFFFF &&
+    if (font->os2->first_char_index != 0xFFFF &&
         ranges[i].start_range != 0xFFFF &&
-        file->os2->first_char_index > ranges[i].start_range) {
-      file->os2->first_char_index = ranges[i].start_range;
+        font->os2->first_char_index > ranges[i].start_range) {
+      font->os2->first_char_index = ranges[i].start_range;
     }
-    if (file->os2->last_char_index != 0xFFFF &&
+    if (font->os2->last_char_index != 0xFFFF &&
         ranges[i].end_range != 0xFFFF &&
-        file->os2->last_char_index < ranges[i].end_range) {
-      file->os2->last_char_index = ranges[i].end_range;
+        font->os2->last_char_index < ranges[i].end_range) {
+      font->os2->last_char_index = ranges[i].end_range;
     }
   }
 
   // The last range must end at 0xffff
   if (ranges[segcount - 1].start_range != 0xffff || ranges[segcount - 1].end_range != 0xffff) {
     return OTS_FAILURE_MSG("Final segment start and end must be 0xFFFF (0x%04X-0x%04X)",
                            ranges[segcount - 1].start_range, ranges[segcount - 1].end_range);
   }
 
   // A format 4 CMAP subtable is complex. To be safe we simulate a lookup of
@@ skipping 25 matching lines @@
         if (glyph >= num_glyphs) {
           return OTS_FAILURE_MSG("Range glyph reference too high (%d > %d)", glyph, num_glyphs - 1);
         }
       }
     }
   }
 
   // We accept the table.
   // TODO(yusukes): transcode the subtable.
   if (platform == 3 && encoding == 0) {
-    file->cmap->subtable_3_0_4_data = data;
-    file->cmap->subtable_3_0_4_length = length;
+    font->cmap->subtable_3_0_4_data = data;
+    font->cmap->subtable_3_0_4_length = length;
   } else if (platform == 3 && encoding == 1) {
-    file->cmap->subtable_3_1_4_data = data;
-    file->cmap->subtable_3_1_4_length = length;
+    font->cmap->subtable_3_1_4_data = data;
+    font->cmap->subtable_3_1_4_length = length;
   } else if (platform == 0 && encoding == 3) {
-    file->cmap->subtable_0_3_4_data = data;
-    file->cmap->subtable_0_3_4_length = length;
+    font->cmap->subtable_0_3_4_data = data;
+    font->cmap->subtable_0_3_4_length = length;
   } else {
     return OTS_FAILURE_MSG("Unknown cmap subtable type (platform=%d, encoding=%d)", platform, encoding);
   }
 
   return true;
 }
 
-bool Parse31012(ots::OpenTypeFile *file,
+bool Parse31012(ots::Font *font,
                 const uint8_t *data, size_t length, uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   // Format 12 tables are simple. We parse these and fully serialise them
   // later.
 
   if (!subtable.Skip(8)) {
     return OTS_FAILURE_MSG("failed to skip the first 8 bytes of format 12 subtable");
   }
   uint32_t language = 0;
   if (!subtable.ReadU32(&language)) {
     return OTS_FAILURE_MSG("can't read format 12 subtable language");
   }
   if (language) {
     return OTS_FAILURE_MSG("format 12 subtable language should be zero (%d)", language);
   }
 
   uint32_t num_groups = 0;
   if (!subtable.ReadU32(&num_groups)) {
     return OTS_FAILURE_MSG("can't read number of format 12 subtable groups");
   }
   if (num_groups == 0 || num_groups > kMaxCMAPGroups) {
     return OTS_FAILURE_MSG("Bad format 12 subtable group count %d", num_groups);
   }
 
   std::vector<ots::OpenTypeCMAPSubtableRange> &groups
-      = file->cmap->subtable_3_10_12;
+      = font->cmap->subtable_3_10_12;
   groups.resize(num_groups);
 
   for (unsigned i = 0; i < num_groups; ++i) {
     if (!subtable.ReadU32(&groups[i].start_range) ||
         !subtable.ReadU32(&groups[i].end_range) ||
         !subtable.ReadU32(&groups[i].start_glyph_id)) {
       return OTS_FAILURE_MSG("can't read format 12 subtable group");
     }
 
     if (groups[i].start_range > kUnicodeUpperLimit ||
@@ skipping 38 matching lines @@
     }
     if (groups[i].start_range <= groups[i - 1].end_range) {
       return OTS_FAILURE_MSG("overlapping format 12 subtable groups (startCharCode=0x%4X <= endCharCode=0x%4X of previous group)",
                              groups[i].start_range, groups[i-1].end_range);
     }
   }
 
   return true;
 }
 
-bool Parse31013(ots::OpenTypeFile *file,
+bool Parse31013(ots::Font *font,
                 const uint8_t *data, size_t length, uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   // Format 13 tables are simple. We parse these and fully serialise them
   // later.
 
   if (!subtable.Skip(8)) {
     return OTS_FAILURE_MSG("Bad cmap subtable length");
   }
   uint32_t language = 0;
   if (!subtable.ReadU32(&language)) {
     return OTS_FAILURE_MSG("Can't read cmap subtable language");
   }
   if (language) {
     return OTS_FAILURE_MSG("Cmap subtable language should be zero but is %d", language);
   }
 
   uint32_t num_groups = 0;
   if (!subtable.ReadU32(&num_groups)) {
     return OTS_FAILURE_MSG("Can't read number of groups in a cmap subtable");
   }
 
   // We limit the number of groups in the same way as in 3.10.12 tables. See
   // the comment there in
   if (num_groups == 0 || num_groups > kMaxCMAPGroups) {
     return OTS_FAILURE_MSG("Bad format 13 subtable group count %d", num_groups);
   }
 
   std::vector<ots::OpenTypeCMAPSubtableRange> &groups
-      = file->cmap->subtable_3_10_13;
+      = font->cmap->subtable_3_10_13;
   groups.resize(num_groups);
 
   for (unsigned i = 0; i < num_groups; ++i) {
     if (!subtable.ReadU32(&groups[i].start_range) ||
         !subtable.ReadU32(&groups[i].end_range) ||
         !subtable.ReadU32(&groups[i].start_glyph_id)) {
       return OTS_FAILURE_MSG("Can't read subrange structure in a cmap subtable");
     }
 
     // We conservatively limit all of the values to protect some parsers from
@@ skipping 15 matching lines @@
       return OTS_FAILURE_MSG("Overlapping subrange starts (%d >= %d)", groups[i]. start_range, groups[i-1].start_range);
     }
     if (groups[i].start_range <= groups[i - 1].end_range) {
       return OTS_FAILURE_MSG("Overlapping subranges (%d <= %d)", groups[i].start_range, groups[i-1].end_range);
     }
   }
 
   return true;
 }
 
-bool Parse0514(ots::OpenTypeFile *file,
+bool Parse0514(ots::Font *font,
                const uint8_t *data, size_t length, uint16_t num_glyphs) {
   // Unicode Variation Selector table
   ots::Buffer subtable(data, length);
 
   // Format 14 tables are simple. We parse these and fully serialise them
   // later.
 
   // Skip format (USHORT) and length (ULONG)
   if (!subtable.Skip(6)) {
     return OTS_FAILURE_MSG("Can't read start of cmap subtable");
   }
 
   uint32_t num_records = 0;
   if (!subtable.ReadU32(&num_records)) {
     return OTS_FAILURE_MSG("Can't read number of records in cmap subtable");
   }
   if (num_records == 0 || num_records > kMaxCMAPSelectorRecords) {
     return OTS_FAILURE_MSG("Bad format 14 subtable records count %d", num_records);
   }
 
   std::vector<ots::OpenTypeCMAPSubtableVSRecord>& records
-      = file->cmap->subtable_0_5_14;
+      = font->cmap->subtable_0_5_14;
   records.resize(num_records);
 
   for (unsigned i = 0; i < num_records; ++i) {
     if (!subtable.ReadU24(&records[i].var_selector) ||
         !subtable.ReadU32(&records[i].default_offset) ||
         !subtable.ReadU32(&records[i].non_default_offset)) {
       return OTS_FAILURE_MSG("Can't read record structure of record %d in cmap subtale", i);
     }
     // Checks the value of variation selector
     if (!((records[i].var_selector >= kMongolianVSStart &&
@@ skipping 87 matching lines @@
           return OTS_FAILURE_MSG("Bad mapping (%04X -> %d) in mapping %d of variation selector %d", mappings[j].unicode_value, mappings[j].glyph_id, j, i);
         }
         last_unicode_value = mappings[j].unicode_value;
       }
     }
   }
 
   if (subtable.offset() != length) {
     return OTS_FAILURE_MSG("Bad subtable offset (%ld != %ld)", subtable.offset(), length);
   }
-  file->cmap->subtable_0_5_14_length = subtable.offset();
+  font->cmap->subtable_0_5_14_length = subtable.offset();
   return true;
 }
 
-bool Parse100(ots::OpenTypeFile *file, const uint8_t *data, size_t length) {
+bool Parse100(ots::Font *font, const uint8_t *data, size_t length) {
   // Mac Roman table
   ots::Buffer subtable(data, length);
 
   if (!subtable.Skip(4)) {
     return OTS_FAILURE_MSG("Bad cmap subtable");
   }
   uint16_t language = 0;
   if (!subtable.ReadU16(&language)) {
     return OTS_FAILURE_MSG("Can't read language in cmap subtable");
   }
   if (language) {
     // simsun.ttf has non-zero language id.
     OTS_WARNING("language id should be zero: %u", language);
   }
 
-  file->cmap->subtable_1_0_0.reserve(kFormat0ArraySize);
+  font->cmap->subtable_1_0_0.reserve(kFormat0ArraySize);
   for (size_t i = 0; i < kFormat0ArraySize; ++i) {
     uint8_t glyph_id = 0;
     if (!subtable.ReadU8(&glyph_id)) {
       return OTS_FAILURE_MSG("Can't read glyph id at array[%ld] in cmap subtable", i);
     }
-    file->cmap->subtable_1_0_0.push_back(glyph_id);
+    font->cmap->subtable_1_0_0.push_back(glyph_id);
   }
 
   return true;
 }
 
 }  // namespace
 
 namespace ots {
 
-bool ots_cmap_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
+bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) {
   Buffer table(data, length);
-  file->cmap = new OpenTypeCMAP;
+  font->cmap = new OpenTypeCMAP;
 
   uint16_t version = 0;
   uint16_t num_tables = 0;
   if (!table.ReadU16(&version) ||
       !table.ReadU16(&num_tables)) {
     return OTS_FAILURE_MSG("Can't read structure of cmap");
   }
 
   if (version != 0) {
     return OTS_FAILURE_MSG("Non zero cmap version (%d)", version);
@@ skipping 133 matching lines @@
   int overlap_count = 0;
   for (unsigned i = 0; i < overlap_checker.size(); ++i) {
     overlap_count += (overlap_checker[i].second ? 1 : -1);
     if (overlap_count > 1) {
       return OTS_FAILURE_MSG("Excessive overlap count %d", overlap_count);
     }
   }
 
   // we grab the number of glyphs in the file from the maxp table to make sure
   // that the character map isn't referencing anything beyound this range.
-  if (!file->maxp) {
+  if (!font->maxp) {
     return OTS_FAILURE_MSG("No maxp table in font! Needed by cmap.");
   }
-  const uint16_t num_glyphs = file->maxp->num_glyphs;
+  const uint16_t num_glyphs = font->maxp->num_glyphs;
 
   // We only support a subset of the possible character map tables. Microsoft
   // 'strongly recommends' that everyone supports the Unicode BMP table with
   // the UCS-4 table for non-BMP glyphs. We'll pass the following subtables:
   //   Platform ID   Encoding ID  Format
   //   0             0            4       (Unicode Default)
   //   0             1            4       (Unicode 1.1)
   //   0             3            4       (Unicode BMP)
   //   0             3            12      (Unicode UCS-4)
   //   0             5            14      (Unicode Variation Sequences)
@@ skipping 16 matching lines @@
   for (unsigned i = 0; i < num_tables; ++i) {
     if (subtable_headers[i].platform == 0) {
       // Unicode platform
 
       if ((subtable_headers[i].encoding == 0 || subtable_headers[i].encoding == 1) &&
           (subtable_headers[i].format == 4)) {
         // parse and output the 0-0-4 and 0-1-4 tables as 3-1-4 table. Sometimes the 0-0-4
         // table actually points to MS symbol data and thus should be parsed as
         // 3-0-4 table (e.g., marqueem.ttf and quixotic.ttf). This error will be
         // recovered in ots_cmap_serialise().
-        if (!ParseFormat4(file, 3, 1, data + subtable_headers[i].offset,
+        if (!ParseFormat4(font, 3, 1, data + subtable_headers[i].offset,
                       subtable_headers[i].length, num_glyphs)) {
           return OTS_FAILURE_MSG("Failed to parse format 4 cmap subtable %d", i);
         }
       } else if ((subtable_headers[i].encoding == 3) &&
                  (subtable_headers[i].format == 4)) {
         // parse and output the 0-3-4 table as 0-3-4 table.
-        if (!ParseFormat4(file, 0, 3, data + subtable_headers[i].offset,
+        if (!ParseFormat4(font, 0, 3, data + subtable_headers[i].offset,
                       subtable_headers[i].length, num_glyphs)) {
           return OTS_FAILURE_MSG("Failed to parse format 4 cmap subtable %d", i);
         }
       } else if ((subtable_headers[i].encoding == 3) &&
                  (subtable_headers[i].format == 12)) {
         // parse and output the 0-3-12 table as 3-10-12 table.
-        if (!Parse31012(file, data + subtable_headers[i].offset,
+        if (!Parse31012(font, data + subtable_headers[i].offset,
                         subtable_headers[i].length, num_glyphs)) {
           return OTS_FAILURE_MSG("Failed to parse format 12 cmap subtable %d", i);
         }
       } else if ((subtable_headers[i].encoding == 5) &&
                  (subtable_headers[i].format == 14)) {
-        if (!Parse0514(file, data + subtable_headers[i].offset,
+        if (!Parse0514(font, data + subtable_headers[i].offset,
                        subtable_headers[i].length, num_glyphs)) {
           return OTS_FAILURE_MSG("Failed to parse format 14 cmap subtable %d", i);
         }
       }
     } else if (subtable_headers[i].platform == 1) {
       // Mac platform
 
       if ((subtable_headers[i].encoding == 0) &&
           (subtable_headers[i].format == 0)) {
         // parse and output the 1-0-0 table.
-        if (!Parse100(file, data + subtable_headers[i].offset,
+        if (!Parse100(font, data + subtable_headers[i].offset,
                       subtable_headers[i].length)) {
           return OTS_FAILURE();
         }
       }
     } else if (subtable_headers[i].platform == 3) {
       // MS platform
 
       switch (subtable_headers[i].encoding) {
         case 0:
         case 1:
           if (subtable_headers[i].format == 4) {
             // parse 3-0-4 or 3-1-4 table.
-            if (!ParseFormat4(file, subtable_headers[i].platform,
+            if (!ParseFormat4(font, subtable_headers[i].platform,
                           subtable_headers[i].encoding,
                           data + subtable_headers[i].offset,
                           subtable_headers[i].length, num_glyphs)) {
               return OTS_FAILURE();
             }
           }
           break;
         case 10:
           if (subtable_headers[i].format == 12) {
-            file->cmap->subtable_3_10_12.clear();
-            if (!Parse31012(file, data + subtable_headers[i].offset,
+            font->cmap->subtable_3_10_12.clear();
+            if (!Parse31012(font, data + subtable_headers[i].offset,
                             subtable_headers[i].length, num_glyphs)) {
               return OTS_FAILURE();
             }
           } else if (subtable_headers[i].format == 13) {
-            file->cmap->subtable_3_10_13.clear();
-            if (!Parse31013(file, data + subtable_headers[i].offset,
+            font->cmap->subtable_3_10_13.clear();
+            if (!Parse31013(font, data + subtable_headers[i].offset,
                             subtable_headers[i].length, num_glyphs)) {
               return OTS_FAILURE();
             }
           }
           break;
       }
     }
   }
 
   return true;
 }
 
-bool ots_cmap_should_serialise(OpenTypeFile *file) {
-  return file->cmap != NULL;
+bool ots_cmap_should_serialise(Font *font) {
+  return font->cmap != NULL;
 }
 
-bool ots_cmap_serialise(OTSStream *out, OpenTypeFile *file) {
-  const bool have_034 = file->cmap->subtable_0_3_4_data != NULL;
-  const bool have_0514 = file->cmap->subtable_0_5_14.size() != 0;
-  const bool have_100 = file->cmap->subtable_1_0_0.size() != 0;
-  const bool have_304 = file->cmap->subtable_3_0_4_data != NULL;
+bool ots_cmap_serialise(OTSStream *out, Font *font) {
+  const bool have_034 = font->cmap->subtable_0_3_4_data != NULL;
+  const bool have_0514 = font->cmap->subtable_0_5_14.size() != 0;
+  const bool have_100 = font->cmap->subtable_1_0_0.size() != 0;
+  const bool have_304 = font->cmap->subtable_3_0_4_data != NULL;
   // MS Symbol and MS Unicode tables should not co-exist.
   // See the comment above in 0-0-4 parser.
-  const bool have_314 = (!have_304) && file->cmap->subtable_3_1_4_data;
-  const bool have_31012 = file->cmap->subtable_3_10_12.size() != 0;
-  const bool have_31013 = file->cmap->subtable_3_10_13.size() != 0;
+  const bool have_314 = (!have_304) && font->cmap->subtable_3_1_4_data;
+  const bool have_31012 = font->cmap->subtable_3_10_12.size() != 0;
+  const bool have_31013 = font->cmap->subtable_3_10_13.size() != 0;
   const uint16_t num_subtables = static_cast<uint16_t>(have_034) +
                                  static_cast<uint16_t>(have_0514) +
                                  static_cast<uint16_t>(have_100) +
                                  static_cast<uint16_t>(have_304) +
                                  static_cast<uint16_t>(have_314) +
                                  static_cast<uint16_t>(have_31012) +
                                  static_cast<uint16_t>(have_31013);
   const off_t table_start = out->Tell();
 
   // Some fonts don't have 3-0-4 MS Symbol nor 3-1-4 Unicode BMP tables
   // (e.g., old fonts for Mac). We don't support them.
   if (!have_304 && !have_314 && !have_034 && !have_31012 && !have_31013) {
     return OTS_FAILURE_MSG("no supported subtables were found");
   }
 
   if (!out->WriteU16(0) ||
       !out->WriteU16(num_subtables)) {
     return OTS_FAILURE();
   }
 
   const off_t record_offset = out->Tell();
   if (!out->Pad(num_subtables * 8)) {
     return OTS_FAILURE();
   }
 
   const off_t offset_034 = out->Tell();
   if (have_034) {
-    if (!out->Write(file->cmap->subtable_0_3_4_data,
-                    file->cmap->subtable_0_3_4_length)) {
+    if (!out->Write(font->cmap->subtable_0_3_4_data,
+                    font->cmap->subtable_0_3_4_length)) {
       return OTS_FAILURE();
     }
   }
 
   const off_t offset_0514 = out->Tell();
   if (have_0514) {
     const std::vector<ots::OpenTypeCMAPSubtableVSRecord> &records
-        = file->cmap->subtable_0_5_14;
+        = font->cmap->subtable_0_5_14;
     const unsigned num_records = records.size();
     if (!out->WriteU16(14) ||
-        !out->WriteU32(file->cmap->subtable_0_5_14_length) ||
+        !out->WriteU32(font->cmap->subtable_0_5_14_length) ||
         !out->WriteU32(num_records)) {
       return OTS_FAILURE();
     }
     for (unsigned i = 0; i < num_records; ++i) {
       if (!out->WriteU24(records[i].var_selector) ||
           !out->WriteU32(records[i].default_offset) ||
           !out->WriteU32(records[i].non_default_offset)) {
         return OTS_FAILURE();
       }
     }
@@ skipping 31 matching lines @@
     }
   }
 
   const off_t offset_100 = out->Tell();
   if (have_100) {
     if (!out->WriteU16(0) ||  // format
         !out->WriteU16(6 + kFormat0ArraySize) ||  // length
         !out->WriteU16(0)) {  // language
       return OTS_FAILURE();
     }
-    if (!out->Write(&(file->cmap->subtable_1_0_0[0]), kFormat0ArraySize)) {
+    if (!out->Write(&(font->cmap->subtable_1_0_0[0]), kFormat0ArraySize)) {
       return OTS_FAILURE();
     }
   }
 
   const off_t offset_304 = out->Tell();
   if (have_304) {
-    if (!out->Write(file->cmap->subtable_3_0_4_data,
-                    file->cmap->subtable_3_0_4_length)) {
+    if (!out->Write(font->cmap->subtable_3_0_4_data,
+                    font->cmap->subtable_3_0_4_length)) {
       return OTS_FAILURE();
     }
   }
 
   const off_t offset_314 = out->Tell();
   if (have_314) {
-    if (!out->Write(file->cmap->subtable_3_1_4_data,
-                    file->cmap->subtable_3_1_4_length)) {
+    if (!out->Write(font->cmap->subtable_3_1_4_data,
+                    font->cmap->subtable_3_1_4_length)) {
       return OTS_FAILURE();
     }
   }
 
   const off_t offset_31012 = out->Tell();
   if (have_31012) {
     std::vector<OpenTypeCMAPSubtableRange> &groups
-        = file->cmap->subtable_3_10_12;
+        = font->cmap->subtable_3_10_12;
     const unsigned num_groups = groups.size();
     if (!out->WriteU16(12) ||
         !out->WriteU16(0) ||
         !out->WriteU32(num_groups * 12 + 16) ||
         !out->WriteU32(0) ||
         !out->WriteU32(num_groups)) {
       return OTS_FAILURE();
     }
 
     for (unsigned i = 0; i < num_groups; ++i) {
       if (!out->WriteU32(groups[i].start_range) ||
           !out->WriteU32(groups[i].end_range) ||
           !out->WriteU32(groups[i].start_glyph_id)) {
         return OTS_FAILURE();
       }
     }
   }
 
   const off_t offset_31013 = out->Tell();
   if (have_31013) {
     std::vector<OpenTypeCMAPSubtableRange> &groups
-        = file->cmap->subtable_3_10_13;
+        = font->cmap->subtable_3_10_13;
     const unsigned num_groups = groups.size();
     if (!out->WriteU16(13) ||
         !out->WriteU16(0) ||
         !out->WriteU32(num_groups * 12 + 16) ||
         !out->WriteU32(0) ||
         !out->WriteU32(num_groups)) {
       return OTS_FAILURE();
     }
 
     for (unsigned i = 0; i < num_groups; ++i) {
@@ skipping 68 matching lines @@
     }
   }
 
   if (!out->Seek(table_end)) {
     return OTS_FAILURE();
   }
 
   return true;
 }
 
-void ots_cmap_free(OpenTypeFile *file) {
-  delete file->cmap;
+void ots_cmap_reuse(Font *font, Font *other) {
+  font->cmap = other->cmap;
+  font->cmap_reused = true;
+}
+
+void ots_cmap_free(Font *font) {
+  delete font->cmap;
 }
 
 }  // namespace ots
 
 #undef TABLE_NAME