Update OTS to revision 99a3b7f

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>
 
 // name - Naming Table
@@ skipping 61 matching lines @@
     return OTS_FAILURE_MSG("Failed to read name count");
   }
 
   uint16_t string_offset = 0;
   if (!table.ReadU16(&string_offset) || string_offset > length) {
     return OTS_FAILURE_MSG("Failed to read strings offset");
   }
   const char* string_base = reinterpret_cast<const char*>(data) +
       string_offset;
 
-  NameRecord prev_record;
   bool sort_required = false;
 
   // Read all the names, discarding any with invalid IDs,
   // and any where the offset/length would be outside the table.
   // A stricter alternative would be to reject the font if there
   // are invalid name records, but it's not clear that is necessary.
   for (unsigned i = 0; i < count; ++i) {
     NameRecord rec;
     uint16_t name_length, name_offset = 0;
     if (!table.ReadU16(&rec.platform_id) ||
@@ skipping 49 matching lines @@
         if (!CheckPsNameAscii(rec.text)) {
           continue;
         }
       } else if (rec.platform_id == 0 || rec.platform_id == 3) {
         if (!CheckPsNameUtf16Be(rec.text)) {
           continue;
         }
       }
     }
 
-    if ((i > 0) && !(prev_record < rec)) {
+    if (!name->names.empty() && !(name->names.back() < rec)) {
       OTS_WARNING("name records are not sorted.");
       sort_required = true;
     }
 
     name->names.push_back(rec);
-    prev_record = rec;
   }
 
   if (format == 1) {
     // extended name table format with language tags
     uint16_t lang_tag_count;
     if (!table.ReadU16(&lang_tag_count)) {
       return OTS_FAILURE_MSG("Failed to read language tag count");
     }
     for (unsigned i = 0; i < lang_tag_count; ++i) {
       uint16_t tag_length = 0;
@@ skipping 34 matching lines @@
     "OTS derived font",
     "1.000",
     "OTS-derived-font"
   };
 
   // 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++) {
+       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;
@@ skipping 48 matching lines @@
     return OTS_FAILURE_MSG("Bad string offset %ld", string_offset);
   }
   if (!out->WriteU16(format) ||
       !out->WriteU16(name_count) ||
       !out->WriteU16(static_cast<uint16_t>(string_offset))) {
     return OTS_FAILURE_MSG("Failed to write name header");
   }
 
   std::string string_data;
   for (std::vector<NameRecord>::const_iterator name_iter = name->names.begin();
-       name_iter != name->names.end(); name_iter++) {
+       name_iter != name->names.end(); ++name_iter) {
     const NameRecord& rec = *name_iter;
     if (string_data.size() + rec.text.size() >
             std::numeric_limits<uint16_t>::max() ||
         !out->WriteU16(rec.platform_id) ||
         !out->WriteU16(rec.encoding_id) ||
         !out->WriteU16(rec.language_id) ||
         !out->WriteU16(rec.name_id) ||
         !out->WriteU16(static_cast<uint16_t>(rec.text.size())) ||
         !out->WriteU16(static_cast<uint16_t>(string_data.size())) ) {
       return OTS_FAILURE_MSG("Faile to write name entry");
     }
     string_data.append(rec.text);
   }
 
   if (format == 1) {
     if (!out->WriteU16(lang_tag_count)) {
       return OTS_FAILURE_MSG("Faile to write language tag count");
     }
     for (std::vector<std::string>::const_iterator tag_iter =
              name->lang_tags.begin();
-         tag_iter != name->lang_tags.end(); tag_iter++) {
+         tag_iter != name->lang_tags.end(); ++tag_iter) {
       if (string_data.size() + tag_iter->size() >
               std::numeric_limits<uint16_t>::max() ||
           !out->WriteU16(static_cast<uint16_t>(tag_iter->size())) ||
           !out->WriteU16(static_cast<uint16_t>(string_data.size()))) {
         return OTS_FAILURE_MSG("Failed to write string");
       }
       string_data.append(*tag_iter);
     }
   }
 
   if (!out->Write(string_data.data(), string_data.size())) {
     return OTS_FAILURE_MSG("Faile to write string data");
   }
 
   return true;
 }
 
 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