Update OTS to revision a7a3b94

third_party/ots/src/name.cc

 // Copyright (c) 2011 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 "name.h"
 
 #include <algorithm>
 #include <cstring>
 
-#include "cff.h"
-
 // name - Naming Table
 // http://www.microsoft.com/typography/otspec/name.htm
 
 #define TABLE_NAME "name"
 
 namespace {
 
 bool ValidInPsName(char c) {
   return (c > 0x20 && c < 0x7f && !std::strchr("[](){}<>/%", c));
 }
@@ skipping 29 matching lines @@
     (*target)[j++] = '\0';
     (*target)[j++] = source[i];
   }
 }
 
 }  // namespace
 
 
 namespace ots {
 
-bool ots_name_parse(OpenTypeFile* file, const uint8_t* data, size_t length) {
+bool ots_name_parse(Font *font, const uint8_t* data, size_t length) {
   Buffer table(data, length);
 
   OpenTypeNAME* name = new OpenTypeNAME;
-  file->name = name;
+  font->name = name;
 
   uint16_t format = 0;
   if (!table.ReadU16(&format) || format > 1) {
     return OTS_FAILURE_MSG("Failed to read name table format or bad format %d", format);
   }
 
   uint16_t count = 0;
   if (!table.ReadU16(&count)) {
     return OTS_FAILURE_MSG("Failed to read name count");
   }
@@ skipping 58 matching lines @@
         name_offset + name_length;
     if (name_end > length) {
       continue;
     }
     rec.text.resize(name_length);
     rec.text.assign(string_base + name_offset, name_length);
 
     if (rec.name_id == 6) {
       // PostScript name: check that it is valid, if not then discard it
       if (rec.platform_id == 1) {
-        if (file->cff && !file->cff->name.empty()) {
-          rec.text = file->cff->name;
-        } else if (!CheckPsNameAscii(rec.text)) {
+        if (!CheckPsNameAscii(rec.text)) {
           continue;
         }
       } else if (rec.platform_id == 0 || rec.platform_id == 3) {
-        if (file->cff && !file->cff->name.empty()) {
-          AssignToUtf16BeFromAscii(&rec.text, file->cff->name);
-        } else if (!CheckPsNameUtf16Be(rec.text)) {
+        if (!CheckPsNameUtf16Be(rec.text)) {
           continue;
         }
       }
     }
 
     if ((i > 0) && !(prev_record < rec)) {
       OTS_WARNING("name records are not sorted.");
       sort_required = true;
     }
 
@@ skipping 40 matching lines @@
   static const uint16_t kStdNameCount = 7;
   static const char* kStdNames[kStdNameCount] = {
     NULL,
     "OTS derived font",
     "Unspecified",
     NULL,
     "OTS derived font",
     "1.000",
     "OTS-derived-font"
   };
-  // The spec says that "In CFF OpenType fonts, these two name strings, when
-  // translated to ASCII, must also be identical to the font name as stored in
-  // the CFF's Name INDEX." And actually, Mac OS X's font parser requires that.
-  if (file->cff && !file->cff->name.empty()) {
-    kStdNames[6] = file->cff->name.c_str();
-  }
 
   // scan the names to check whether the required "standard" ones are present;
   // if not, we'll add our fixed versions here
   bool mac_name[kStdNameCount] = { 0 };
   bool win_name[kStdNameCount] = { 0 };
   for (std::vector<NameRecord>::iterator name_iter = name->names.begin();
        name_iter != name->names.end(); name_iter++) {
     const uint16_t id = name_iter->name_id;
     if (id >= kStdNameCount || kStdNames[id] == NULL) {
       continue;
     }
     if (name_iter->platform_id == 1) {
       mac_name[id] = true;
       continue;
     }
     if (name_iter->platform_id == 3) {
       win_name[id] = true;
       continue;
     }
   }
 
   for (uint16_t i = 0; i < kStdNameCount; ++i) {
     if (kStdNames[i] == NULL) {
       continue;
     }
-    if (!mac_name[i]) {
-      NameRecord rec(1 /* platform_id */, 0 /* encoding_id */,
-                     0 /* language_id */ , i /* name_id */);
-      rec.text.assign(kStdNames[i]);
-      name->names.push_back(rec);
-      sort_required = true;
-    }
-    if (!win_name[i]) {
-      NameRecord rec(3 /* platform_id */, 1 /* encoding_id */,
-                     1033 /* language_id */ , i /* name_id */);
-      AssignToUtf16BeFromAscii(&rec.text, std::string(kStdNames[i]));
-      name->names.push_back(rec);
+    if (!mac_name[i] && !win_name[i]) {
+      NameRecord mac_rec(1 /* platform_id */, 0 /* encoding_id */,
+                         0 /* language_id */ , i /* name_id */);
+      mac_rec.text.assign(kStdNames[i]);
+
+      NameRecord win_rec(3 /* platform_id */, 1 /* encoding_id */,
+                         1033 /* language_id */ , i /* name_id */);
+      AssignToUtf16BeFromAscii(&win_rec.text, std::string(kStdNames[i]));
+
+      name->names.push_back(mac_rec);
+      name->names.push_back(win_rec);
       sort_required = true;
     }
   }
 
   if (sort_required) {
     std::sort(name->names.begin(), name->names.end());
   }
 
   return true;
 }
 
-bool ots_name_should_serialise(OpenTypeFile* file) {
-  return file->name != NULL;
+bool ots_name_should_serialise(Font *font) {
+  return font->name != NULL;
 }
 
-bool ots_name_serialise(OTSStream* out, OpenTypeFile* file) {
-  const OpenTypeNAME* name = file->name;
+bool ots_name_serialise(OTSStream* out, Font *font) {
+  const OpenTypeNAME* name = font->name;
 
   uint16_t name_count = static_cast<uint16_t>(name->names.size());
   uint16_t lang_tag_count = static_cast<uint16_t>(name->lang_tags.size());
   uint16_t format = 0;
   size_t string_offset = 6 + name_count * 12;
 
   if (name->lang_tags.size() > 0) {
     // lang tags require a format-1 name table
     format = 1;
     string_offset += 2 + lang_tag_count * 4;
@@ skipping 41 matching lines @@
     }
   }
 
   if (!out->Write(string_data.data(), string_data.size())) {
     return OTS_FAILURE_MSG("Faile to write string data");
   }
 
   return true;
 }
 
-void ots_name_free(OpenTypeFile* file) {
-  delete file->name;
+void ots_name_reuse(Font *font, Font *other) {
+  font->name = other->name;
+  font->name_reused = true;
+}
+
+void ots_name_free(Font *font) {
+  delete font->name;
 }
 
 }  // namespace
 
 #undef TABLE_NAME