Roll sfntly to r98

third_party/sfntly/src/subsetter/subsetter_impl.cc

 /*
  * Copyright 2011 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,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 #include "third_party/sfntly/src/subsetter/subsetter_impl.h"
 
 #include <string.h>
 
 #include <map>
 #include <set>
 
-#include "third_party/sfntly/src/sfntly/glyph_table.h"
-#include "third_party/sfntly/src/sfntly/loca_table.h"
-#include "third_party/sfntly/src/sfntly/name_table.h"
+#include "third_party/sfntly/src/sfntly/table/core/name_table.h"
+#include "third_party/sfntly/src/sfntly/table/truetype/glyph_table.h"
+#include "third_party/sfntly/src/sfntly/table/truetype/loca_table.h"
 #include "third_party/sfntly/src/sfntly/tag.h"
 #include "third_party/sfntly/src/sfntly/data/memory_byte_array.h"
+#include "third_party/sfntly/src/sfntly/port/memory_input_stream.h"
 #include "third_party/sfntly/src/sfntly/port/memory_output_stream.h"
 
 namespace sfntly {
 
 void ConstructName(UChar* name_part, UnicodeString* name, int32_t name_id) {
   switch(name_id) {
     case NameId::kFullFontName:
       *name = name_part;
       break;
     case NameId::kFontFamilyName:
@@ skipping 33 matching lines @@
 
 SubsetterImpl::SubsetterImpl() {
 }
 
 SubsetterImpl::~SubsetterImpl() {
 }
 
 bool SubsetterImpl::LoadFont(const char* font_name,
                              const unsigned char* original_font,
                              size_t font_size) {
-  ByteArrayPtr raw_font =
-      new MemoryByteArray((byte_t*)original_font, font_size);
+  MemoryInputStream mis;
+  mis.Attach(original_font, font_size);
   if (factory_ == NULL) {
     factory_.Attach(FontFactory::GetInstance());
   }
 
   FontArray font_array;
-  factory_->LoadFonts(raw_font, &font_array);
+  factory_->LoadFonts(&mis, &font_array);
   font_ = FindFont(font_name, font_array);
   if (font_ == NULL) {
     return false;
   }
 
   return true;
 }
 
 int SubsetterImpl::SubsetFont(const unsigned int* glyph_ids,
                               size_t glyph_count,
@@ skipping 114 matching lines @@
   for (size_t i = 0; i < glyph_count; ++i) {
     glyph_id_remaining.insert(glyph_ids[i]);
   }
 
   // Identify if any given glyph id maps to a composite glyph.  If so, include
   // the glyphs referenced by that composite glyph.
   while (!glyph_id_remaining.empty()) {
     IntegerSet comp_glyph_id;
     for (IntegerSet::iterator i = glyph_id_remaining.begin(),
                               e = glyph_id_remaining.end(); i != e; ++i) {
-      if (*i < 0 || *i >= loca_table->NumGlyphs()) {
+      if (*i < 0 || *i >= loca_table->num_glyphs()) {
         // Invalid glyph id, ignore.
         continue;
       }
 
       int32_t length = loca_table->GlyphLength(*i);
       if (length == 0) {
         // Empty glyph, ignore.
         continue;
       }
       int32_t offset = loca_table->GlyphOffset(*i);
@@ skipping 30 matching lines @@
 CALLER_ATTACH Font* SubsetterImpl::Subset(const IntegerSet& glyph_ids) {
   // The tables are already checked in ResolveCompositeGlyphs().
   GlyphTablePtr glyph_table =
       down_cast<GlyphTable*>(font_->GetTable(Tag::glyf));
   LocaTablePtr loca_table = down_cast<LocaTable*>(font_->GetTable(Tag::loca));
 
   // Setup font builders we need.
   FontBuilderPtr font_builder;
   font_builder.Attach(factory_->NewFontBuilder());
 
-  GlyphTableBuilderPtr glyph_table_builder;
-  glyph_table_builder.Attach(down_cast<GlyphTable::Builder*>(
-      font_builder->NewTableBuilder(Tag::glyf)));
-  LocaTableBuilderPtr loca_table_builder;
-  loca_table_builder.Attach(down_cast<LocaTable::Builder*>(
-      font_builder->NewTableBuilder(Tag::loca)));
+  GlyphTableBuilderPtr glyph_table_builder =
+      down_cast<GlyphTable::Builder*>(font_builder->NewTableBuilder(Tag::glyf));
+  LocaTableBuilderPtr loca_table_builder =
+      down_cast<LocaTable::Builder*>(font_builder->NewTableBuilder(Tag::loca));
   if (glyph_table_builder == NULL || loca_table_builder == NULL) {
     // Out of memory.
     return NULL;
   }
 
   // Extract glyphs and setup loca list.
   IntegerList loca_list;
-  loca_list.resize(loca_table->NumGlyphs());
+  loca_list.resize(loca_table->num_glyphs());
   loca_list.push_back(0);
   int32_t last_glyph_id = 0;
   int32_t last_offset = 0;
   GlyphTable::GlyphBuilderList* glyph_builders =
       glyph_table_builder->GlyphBuilders();
   for (IntegerSet::const_iterator i = glyph_ids.begin(), e = glyph_ids.end();
                                   i != e; ++i) {
     int32_t length = loca_table->GlyphLength(*i);
     int32_t offset = loca_table->GlyphOffset(*i);
 
     GlyphPtr glyph;
     glyph.Attach(glyph_table->GetGlyph(offset, length));
 
     // Add glyph to new glyf table.
     ReadableFontDataPtr data = glyph->ReadFontData();
     WritableFontDataPtr copy_data;
-    copy_data.Attach(font_builder->GetNewData(data->Length()));
+    copy_data.Attach(WritableFontData::CreateWritableFontData(data->Length()));
     data->CopyTo(copy_data);
     GlyphBuilderPtr glyph_builder;
     glyph_builder.Attach(glyph_table_builder->GlyphBuilder(copy_data));
     glyph_builders->push_back(glyph_builder);
 
     // Configure loca list.
     for (int32_t j = last_glyph_id + 1; j <= *i; ++j) {
       loca_list[j] = last_offset;
     }
     last_offset += length;
     loca_list[*i + 1] = last_offset;
     last_glyph_id = *i;
   }
-  for (int32_t j = last_glyph_id + 1; j <= loca_table->NumGlyphs(); ++j) {
+  for (int32_t j = last_glyph_id + 1; j <= loca_table->num_glyphs(); ++j) {
     loca_list[j] = last_offset;
   }
   loca_table_builder->SetLocaList(&loca_list);
 
   // Setup remaining builders.
-  for (TableMap::iterator i = font_->Tables()->begin(),
-                          e = font_->Tables()->end(); i != e; ++i) {
+  for (TableMap::const_iterator i = font_->GetTableMap()->begin(),
+                                e = font_->GetTableMap()->end(); i != e; ++i) {
     // We already build the builder for glyph and loca.
     if (i->first != Tag::glyf && i->first != Tag::loca) {
-      // The newTableBuilder() call will alter internal state of font_builder
-      // AND the reference count of returned object.  Therefore we need to
-      // dereference it.
-      TableBuilderPtr dereference;
-      dereference.Attach(
-          font_builder->NewTableBuilder(i->first, i->second->ReadFontData()));
+      font_builder->NewTableBuilder(i->first, i->second->ReadFontData());
     }
   }
 
   return font_builder->Build();
 }
 
 }  // namespace sfntly