freetypefont.cc

Go to the documentation of this file.

#include "ion/text/freetypefont.h"

#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_MODULE_H
#include FT_SYSTEM_H
#include FT_TRUETYPE_TABLES_H

#include <algorithm>
#include <cstring>  // For memcpy().
#include <memory>
#include <mutex>  // NOLINT(build/c++11): only using std::call_once, not mutex.
#include <unordered_map>
#include <vector>

#include "ion/base/allocator.h"
#include "ion/base/datacontainer.h"
#include "ion/base/lockguards.h"
#include "ion/base/logging.h"
#include "ion/base/staticsafedeclare.h"
#include "ion/port/fileutils.h"
#include "ion/port/memorymappedfile.h"
#include "ion/port/mutex.h"
#include "ion/text/freetypefontutils.h"
#include "ion/text/layout.h"
#if defined(ION_USE_ICU)
#include "third_party/icu/icu4c/source/common/unicode/udata.h"
#include "third_party/iculehb/src/src/LEFontInstance.h"
#include "third_party/iculx_hb/include/layout/ParagraphLayout.h"
#endif  // ION_USE_ICU

namespace ion {
namespace text {

namespace {

using math::Vector2f;

typedef std::vector<math::Point2f> ControlPoints;

static bool IsSizeValid(const Vector2f& target_size) {
  const float width = target_size[0];
  const float height = target_size[1];
  return width >= 0.0f && height >= 0.0f && (width > 0.0f || height > 0.0f);
}




class FreeTypeManager {
 public:
  explicit FreeTypeManager(const base::AllocatorPtr& allocator);
  ~FreeTypeManager();

  static FreeTypeManager* GetManagerForAllocator(
      const base::AllocatorPtr& allocator) {
    typedef std::unordered_map<base::Allocator*,
                               std::unique_ptr<FreeTypeManager>>
        FreeTypeManagerMap;
    ION_DECLARE_SAFE_STATIC_POINTER(FreeTypeManagerMap, map);
    ION_DECLARE_SAFE_STATIC_POINTER(ion::port::Mutex, mutex);

    base::AllocatorPtr allocator_to_use =
        allocator.Get()
            ? allocator
            : base::AllocationManager::GetDefaultAllocatorForLifetime(
                  base::kLongTerm);

    ion::base::LockGuard lock(mutex);
    auto it = map->find(allocator_to_use.Get());
    if (it == map->end()) {
      auto man = new FreeTypeManager(allocator);
      (*map)[allocator_to_use.Get()] = std::unique_ptr<FreeTypeManager>(man);
      return man;
    }
    return it->second.get();
  }

  FT_Face InitFont(const void* data, size_t data_size,
                   bool simulate_library_failure);

  bool LoadGlyph(FT_Face face, uint32 glyph_index);

  void FreeFont(FT_Face face);

 private:
  static void* Allocate(FT_Memory mem, long size);  // NOLINT
  static void Free(FT_Memory mem, void* ptr);
  static void* Realloc(FT_Memory mem, long cur_size, long new_size,  // NOLINT
                       void* ptr);

  static const base::AllocatorPtr& GetAllocator(FT_Memory mem) {
    DCHECK(mem);
    DCHECK(mem->user);
    FreeTypeManager* mgr = static_cast<FreeTypeManager*>(mem->user);
    DCHECK(mgr->mutex_.IsLocked());
    DCHECK(mgr->allocator_.Get());
    return mgr->allocator_;
  }

  base::AllocatorPtr allocator_;
  FT_MemoryRec_ ft_mem_;
  FT_Library ft_lib_;
  port::Mutex mutex_;
};

FreeTypeManager::FreeTypeManager(const base::AllocatorPtr& allocator)
    : allocator_(allocator), ft_lib_(NULL) {
  ft_mem_.user = this;
  ft_mem_.alloc = Allocate;
  ft_mem_.free = Free;
  ft_mem_.realloc = Realloc;

  base::LockGuard guard(&mutex_);
  FT_New_Library(&ft_mem_, &ft_lib_);
  if (ft_lib_) FT_Add_Default_Modules(ft_lib_);
}

FreeTypeManager::~FreeTypeManager() {
  base::LockGuard guard(&mutex_);
  if (ft_lib_) FT_Done_Library(ft_lib_);
}

FT_Face FreeTypeManager::InitFont(const void* data, size_t data_size,
                                  bool simulate_library_failure) {
  FT_Face face = NULL;
  base::LockGuard guard(&mutex_);
  if (FT_Library lib = simulate_library_failure ? NULL : ft_lib_) {
    if (!FT_New_Memory_Face(lib, reinterpret_cast<const FT_Byte*>(data),
                            static_cast<FT_Long>(data_size), 0, &face)) {
      DCHECK(face);
    } else {
      LOG(ERROR) << "Could not read the FreeType font data";
      face = NULL;
    }
  } else {
    LOG(ERROR) << "Could not initialize the FreeType library";
  }
  return face;
}

void FreeTypeManager::FreeFont(FT_Face face) {
  if (face) {
    base::LockGuard guard(&mutex_);
    FT_Done_Face(face);
  }
}

bool FreeTypeManager::LoadGlyph(FT_Face face, uint32 glyph_index) {
  base::LockGuard guard(&mutex_);
  const FT_Error result = FT_Load_Glyph(face, glyph_index, FT_LOAD_RENDER);
  return result == 0;
}

void* FreeTypeManager::Allocate(FT_Memory mem, long size) {  // NOLINT
  return GetAllocator(mem)->AllocateMemory(size);
}

void FreeTypeManager::Free(FT_Memory mem, void* ptr) {
  GetAllocator(mem)->DeallocateMemory(ptr);
}

void* FreeTypeManager::Realloc(FT_Memory mem, long cur_size,  // NOLINT
                               long new_size, void* ptr) {    // NOLINT
  const base::AllocatorPtr& allocator = GetAllocator(mem);
  void* new_ptr = allocator->AllocateMemory(new_size);
  memcpy(new_ptr, ptr, cur_size);
  allocator->DeallocateMemory(ptr);
  return new_ptr;
}




static float ToPixels(FT_Pos v26_6) {
  static const float kToPixels = 1.0f / 64.0f;
  return kToPixels * static_cast<float>(v26_6);
}

static const FreeTypeFont::GlyphMetrics GlyphToMetrics(
    const FT_GlyphSlot& glyph) {
  FreeTypeFont::GlyphMetrics metrics;
  metrics.size.Set(ToPixels(glyph->metrics.width),
                   ToPixels(glyph->metrics.height));
  metrics.bitmap_offset.Set(static_cast<float>(glyph->bitmap_left),
                            static_cast<float>(glyph->bitmap_top));
  metrics.advance.Set(ToPixels(glyph->advance.x), ToPixels(glyph->advance.y));
  return metrics;
}

static void GlyphToControlPoints(const FT_GlyphSlot& glyph,
                                 ControlPoints* control_points) {
  DCHECK_EQ(control_points->size(), 0U);
  if (glyph->format != FT_GLYPH_FORMAT_OUTLINE) return;
  const FT_Outline& outline = glyph->outline;
  control_points->reserve(outline.n_points);
  for (int16 i = 0; i < outline.n_points; ++i) {
    control_points->push_back(math::Point2f(ToPixels(outline.points[i].x),
                                            ToPixels(outline.points[i].y)));
  }
}

static const Font::GlyphGrid GlyphToGrid(const FT_GlyphSlot& glyph) {
  const FT_Bitmap bitmap = glyph->bitmap;
  const size_t width = bitmap.width;
  const size_t height = bitmap.rows;
  const size_t pitch = bitmap.pitch;

  Font::GlyphGrid grid(width, height);
  for (size_t y = 0; y < height; ++y) {
    for (size_t x = 0; x < width; ++x) {
      grid.pixels.Set(
          x, y, static_cast<double>(bitmap.buffer[y * pitch + x]) / 255.0);
    }
  }
  return grid;
}


static uint32 GlyphIndexToGlyphId(const GlyphIndex glyph) {
  return static_cast<uint32>(glyph & 0xFFFFFFFF);
}

static uint32 GlyphIndexToFaceId(const GlyphIndex glyph) {
  return static_cast<uint32>(glyph >> 32);
}

static GlyphIndex BuildGlyphIndex(uint32 glyph, uint32 face) {
  return static_cast<GlyphIndex>(glyph) | (static_cast<GlyphIndex>(face) << 32);
}

}  // anonymous namespace




class FreeTypeFont::Helper
#if defined(ION_USE_ICU)
    : public icu::LEFontInstance
#endif
{
 public:
  struct GlyphMetaData : public Allocatable {
    bool IsZeroSize() const { return metrics.IsZeroSize(); }

    GlyphMetrics metrics;
    ControlPoints control_points;
  };

  explicit Helper(FreeTypeFont* owning_font)
      : glyph_metadata_map_(owning_font->GetAllocator()),
        owning_font_(owning_font),
        allocator_(owning_font_->GetAllocator()),
#if defined(ION_USE_ICU)
        font_tables_(allocator_),
#endif  // ION_USE_ICU
        ft_face_(NULL),
        manager_(FreeTypeManager::GetManagerForAllocator(allocator_)) {
  }
  ~Helper() { FreeFont(); }

  bool Init(const void* data, size_t data_size, bool simulate_library_failure);

  bool LoadGlyph(GlyphIndex glyph_index, GlyphMetaData* glyph_meta,
                 Font::GlyphGrid* glyph_grid) const;

  const FontMetrics GetFontMetrics() const;

  const math::Vector2f GetKerning(CharIndex char_index0,
                                  CharIndex char_index1) const;

  GlyphIndex GetDefaultGlyphForChar(CharIndex char_index) const;

  const GlyphMetaData& GetGlyphMetaData(GlyphIndex glyph_index) const;

  void FreeFont();

  void AddFallbackFace(const std::weak_ptr<Helper>& fallback);

#if defined(ION_USE_ICU)
  const void* getFontTable(LETag tableTag, size_t& length) const override;
  le_int32 getUnitsPerEM() const override;
  LEGlyphID mapCharToGlyph(LEUnicode32 ch) const override;
  void getGlyphAdvance(LEGlyphID glyph, LEPoint& advance) const override;
  le_bool getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber,
                        LEPoint& point) const override;
  float getXPixelsPerEm() const override;
  float getYPixelsPerEm() const override;
  float getScaleFactorX() const override;
  float getScaleFactorY() const override;
  le_int32 getAscent() const override;
  le_int32 getDescent() const override;
  le_int32 getLeading() const override;

  const icu::LEFontInstance* GetFace(uint32 index) const;
  GlyphIndex GlyphIndexForICUFont(const icu::LEFontInstance* icu_font,
                                  int32 glyph_id) const;
#endif

 private:
  void SetFontSizeLocked() const;

  uint32 GetGlyphForChar(CharIndex char_index) const;

  bool GetKerningNoFallback(CharIndex char_index0, CharIndex char_index1,
                            math::Vector2f* kern) const;

  const math::Vector2f GetKerningLocked(CharIndex char_index0,
                                        CharIndex char_index1) const;

  bool LoadGlyphLocked(GlyphIndex glyph_index, GlyphMetaData* glyph_meta,
                       Font::GlyphGrid* glyph_grid) const;

  bool LoadGlyphLockedNoFallback(GlyphIndex glyph_index,
                                 GlyphMetaData* glyph_meta,
                                 Font::GlyphGrid* glyph_grid) const;

  typedef base::AllocMap<GlyphIndex, GlyphMetaData> GlyphMetaDataMap;

  mutable GlyphMetaDataMap glyph_metadata_map_;

  FreeTypeFont* owning_font_;
  base::AllocatorPtr allocator_;
#if defined(ION_USE_ICU)
  mutable base::AllocMap<LETag, std::pair<base::DataContainerPtr, size_t>>
      font_tables_;
#endif
  FT_Face ft_face_;
  std::vector<std::weak_ptr<Helper>> fallback_helpers_;
  FreeTypeManager* manager_;
  mutable port::Mutex mutex_;
};

bool FreeTypeFont::Helper::Init(const void* data, size_t data_size,
                                bool simulate_library_failure) {
  DCHECK(!ft_face_);
  base::LockGuard guard(&mutex_);
  ft_face_ = manager_->InitFont(data, data_size, simulate_library_failure);
  if (!ft_face_) {
    LOG(ERROR) << "Could not read the FreeType font data.";
  }
  return ft_face_;
}

bool FreeTypeFont::Helper::LoadGlyph(GlyphIndex glyph_index,
                                     GlyphMetaData* glyph_meta,
                                     Font::GlyphGrid* glyph_grid) const {
  base::LockGuard guard(&mutex_);
  return LoadGlyphLocked(glyph_index, glyph_meta, glyph_grid);
}

bool FreeTypeFont::Helper::LoadGlyphLocked(GlyphIndex glyph_index,
                                           GlyphMetaData* glyph_meta,
                                           Font::GlyphGrid* glyph_grid) const {
  uint32 face_id = GlyphIndexToFaceId(glyph_index);
  if (face_id == 0) {
    return LoadGlyphLockedNoFallback(glyph_index, glyph_meta, glyph_grid);
  } else {
    if (auto helper = fallback_helpers_[face_id - 1].lock()) {
      base::LockGuard guard(&helper->mutex_);
      return helper->LoadGlyphLockedNoFallback(glyph_index, glyph_meta,
                                               glyph_grid);
    } else {
      return false;
    }
  }
}

bool FreeTypeFont::Helper::LoadGlyphLockedNoFallback(
    GlyphIndex glyph_index, GlyphMetaData* glyph_meta,
    Font::GlyphGrid* glyph_grid) const {
  DCHECK(ft_face_);

  SetFontSizeLocked();

  if (!manager_->LoadGlyph(ft_face_, GlyphIndexToGlyphId(glyph_index))) {
    return false;
  }

  if (glyph_meta) {
    glyph_meta->metrics = GlyphToMetrics(ft_face_->glyph);
    GlyphToControlPoints(ft_face_->glyph, &glyph_meta->control_points);
  }
  if (glyph_grid) {
    *glyph_grid = GlyphToGrid(ft_face_->glyph);
  }
  return true;
}

void FreeTypeFont::Helper::SetFontSizeLocked() const {
  const size_t size_in_pixels = owning_font_->GetSizeInPixels();
  if (FT_IS_SCALABLE(ft_face_)) {
    FT_Set_Pixel_Sizes(ft_face_, static_cast<FT_UInt>(size_in_pixels),
                       static_cast<FT_UInt>(size_in_pixels));
  } else {  // Must be fixed size (bitmap) font.
    DCHECK(ft_face_->num_fixed_sizes);
    int closest_face = 0;  // Index of bitmap-strike closest to size_in_pixels.
    size_t closest_size = 0xFFFFFFFF;
    for (int i = 0; i < ft_face_->num_fixed_sizes; ++i) {
      FT_Select_Size(ft_face_, i);
      const size_t size_difference =
          abs(static_cast<int>(ft_face_->size->metrics.y_ppem) -
              static_cast<int>(size_in_pixels));
      if (size_difference < closest_size) {
        closest_size = size_difference;
        closest_face = i;
      }
    }
    FT_Select_Size(ft_face_, closest_face);
  }
}

const Font::FontMetrics FreeTypeFont::Helper::GetFontMetrics() const {
  base::LockGuard guard(&mutex_);
  FontMetrics metrics;
  SetFontSizeLocked();
  metrics.line_advance_height =
      static_cast<float>(ft_face_->size->metrics.height / 64);
  return metrics;
}

const math::Vector2f FreeTypeFont::Helper::GetKerning(
    CharIndex char_index0, CharIndex char_index1) const {
  math::Vector2f retval = math::Vector2f::Zero();
  if (GetKerningNoFallback(char_index0, char_index1, &retval)) {
    return retval;
  }

  for (auto& fallback_helper : fallback_helpers_) {
    auto fallback = fallback_helper.lock();
    if (fallback &&
        fallback->GetKerningNoFallback(char_index0, char_index1, &retval)) {
      return retval;
    }
  }
  return retval;
}

bool FreeTypeFont::Helper::GetKerningNoFallback(CharIndex char_index0,
                                                CharIndex char_index1,
                                                math::Vector2f* kern) const {
  const uint32 idx0 = GetGlyphForChar(char_index0);
  const uint32 idx1 = GetGlyphForChar(char_index1);
  base::LockGuard guard(&mutex_);
  if (idx0 != 0 && idx1 != 0) {
    *kern = GetKerningLocked(char_index0, char_index1);
    return true;
  } else if (idx0 != 0 || idx1 != 0) {
    *kern = math::Vector2f::Zero();
    return true;
  }
  return false;
}

const math::Vector2f FreeTypeFont::Helper::GetKerningLocked(
    CharIndex char_index0, CharIndex char_index1) const {
  math::Vector2f kerning(0.f, 0.f);
  FT_Vector ft_kerning;
  if (ft_face_ && FT_HAS_KERNING(ft_face_) &&
      !FT_Get_Kerning(ft_face_, static_cast<FT_UInt>(char_index0),
                      static_cast<FT_UInt>(char_index1), FT_KERNING_DEFAULT,
                      &ft_kerning)) {
    kerning.Set(ToPixels(ft_kerning.x), ToPixels(ft_kerning.y));
  }
  return kerning;
}

uint32 FreeTypeFont::Helper::GetGlyphForChar(CharIndex char_index) const {
  base::LockGuard guard(&mutex_);
  return FT_Get_Char_Index(ft_face_, char_index);
}

GlyphIndex FreeTypeFont::Helper::GetDefaultGlyphForChar(
    CharIndex char_index) const {
  uint32 idx = GetGlyphForChar(char_index);
  if (idx != 0) {
    return BuildGlyphIndex(idx, 0);
  }
  for (uint32 i = 0; i < fallback_helpers_.size(); ++i) {
    if (auto helper = fallback_helpers_[i].lock()) {
      idx = helper->GetGlyphForChar(char_index);
      if (idx != 0) {
        return BuildGlyphIndex(idx, i + 1);
      }
    }
  }
  return BuildGlyphIndex(GetGlyphForChar(static_cast<CharIndex>(0xfffd)), 0);
}

const FreeTypeFont::Helper::GlyphMetaData&
FreeTypeFont::Helper::GetGlyphMetaData(GlyphIndex glyph_index) const {
  base::LockGuard guard(&mutex_);
  if (!glyph_index) {
    return base::InvalidReference<GlyphMetaData>();
  }
  const auto& it = glyph_metadata_map_.find(glyph_index);
  if (it == glyph_metadata_map_.end()) {
    GlyphMetaData glyph_meta;
    if (LoadGlyphLocked(glyph_index, &glyph_meta, NULL)) {
      return glyph_metadata_map_[glyph_index] = glyph_meta;
    }
    return base::InvalidReference<GlyphMetaData>();
  }
  return it->second;
}

void FreeTypeFont::Helper::FreeFont() {
  base::LockGuard guard(&mutex_);
  if (ft_face_) {
    manager_->FreeFont(ft_face_);
    ft_face_ = NULL;
  }
}

void FreeTypeFont::Helper::AddFallbackFace(
    const std::weak_ptr<Helper>& fallback) {
  auto locked_fallback = fallback.lock();
  if (!locked_fallback || locked_fallback.get() == this) {
    return;
  }
  base::LockGuard guard(&mutex_);
  fallback_helpers_.push_back(fallback);
}

#if defined(ION_USE_ICU)
const void* FreeTypeFont::Helper::getFontTable(LETag tableTag,
                                               size_t& length) const {
  auto it = font_tables_.find(tableTag);
  if (it == font_tables_.end()) {
    FT_ULong table_size = 0;
    FT_Error error =
        FT_Load_Sfnt_Table(ft_face_, tableTag, 0, NULL, &table_size);
    if (!error && error != FT_Err_Table_Missing) {
      base::DataContainerPtr table =
          base::DataContainer::CreateOverAllocated<FT_Byte>(table_size, NULL,
                                                            allocator_);
      error = FT_Load_Sfnt_Table(ft_face_, tableTag, 0,
                                 table->GetMutableData<FT_Byte>(), &table_size);
      DCHECK_EQ(error, 0);
      auto inserted = font_tables_.insert(
          std::make_pair(tableTag, std::make_pair(table, table_size)));
      DCHECK(inserted.second);
      it = inserted.first;
    }
  }
  if (it == font_tables_.end()) {
    length = 0;
    return NULL;
  }
  length = it->second.second;
  return it->second.first->GetMutableData<uint8>();
}

le_int32 FreeTypeFont::Helper::getUnitsPerEM() const {
  return ft_face_->units_per_EM;
}

LEGlyphID FreeTypeFont::Helper::mapCharToGlyph(LEUnicode32 ch) const {
  return FT_Get_Char_Index(ft_face_, ch);
}

static void SetLEPointToZero(LEPoint* point) {
  point->fX = 0.f;
  point->fY = 0.f;
}

void FreeTypeFont::Helper::getGlyphAdvance(LEGlyphID glyph,
                                           LEPoint& advance) const {
  const GlyphMetaData& data = GetGlyphMetaData(glyph);
  if (base::IsInvalidReference(data)) return SetLEPointToZero(&advance);
  const FreeTypeFont::GlyphMetrics& metrics = data.metrics;
  advance.fX = metrics.advance[0];
  advance.fY = metrics.advance[1];
}

le_bool FreeTypeFont::Helper::getGlyphPoint(LEGlyphID glyph,
                                            le_int32 pointNumber,
                                            LEPoint& point) const {
  const GlyphMetaData& data = GetGlyphMetaData(glyph);
  if (base::IsInvalidReference(data)) {
    SetLEPointToZero(&point);
    return false;
  }
  const ControlPoints& control_points = data.control_points;
  if (static_cast<size_t>(pointNumber) < control_points.size()) {
    point.fX = control_points[pointNumber][0];
    point.fY = control_points[pointNumber][1];
    return true;
  }
  return false;
}

float FreeTypeFont::Helper::getXPixelsPerEm() const {
  return ft_face_->size->metrics.x_ppem;
}

float FreeTypeFont::Helper::getYPixelsPerEm() const {
  return ft_face_->size->metrics.y_ppem;
}

float FreeTypeFont::Helper::getScaleFactorX() const {
  static const float k16_16ToFloat = 1.0f / 65536.0f;
  return static_cast<float>(ft_face_->size->metrics.x_scale) * k16_16ToFloat;
}

float FreeTypeFont::Helper::getScaleFactorY() const {
  static const float k16_16ToFloat = 1.0f / 65536.0f;
  return static_cast<float>(ft_face_->size->metrics.y_scale) * k16_16ToFloat;
}

le_int32 FreeTypeFont::Helper::getAscent() const {
  return static_cast<le_int32>(
      FT_MulFix(ft_face_->ascender,
                static_cast<FT_Int32>(ft_face_->size->metrics.y_scale)) /
      64);
}

le_int32 FreeTypeFont::Helper::getDescent() const {
  return -static_cast<le_int32>(
      FT_MulFix(ft_face_->descender, ft_face_->size->metrics.y_scale) / 64);
}

le_int32 FreeTypeFont::Helper::getLeading() const {
  return static_cast<le_int32>(
      FT_MulFix(ft_face_->height,
                static_cast<FT_Int32>(ft_face_->size->metrics.y_scale)) /
      64);
}

const icu::LEFontInstance* FreeTypeFont::Helper::GetFace(uint32 index) const {
  if (index == 0) {
    return this;
  }
  auto helper = fallback_helpers_[index - 1].lock();
  if (helper) {
    return helper.get();
  }
  return nullptr;
}

GlyphIndex FreeTypeFont::Helper::GlyphIndexForICUFont(
    const icu::LEFontInstance* icu_font, int32 glyph_id) const {
  for (uint32 i = 0, n = static_cast<uint32>(fallback_helpers_.size()); i <= n;
       ++i) {
    if (icu_font == GetFace(i)) {
      return BuildGlyphIndex(glyph_id, i);
    }
  }
  return BuildGlyphIndex(glyph_id, 0);
}

#endif  // ION_USE_ICU




FreeTypeFont::FreeTypeFont(const std::string& name, size_t size_in_pixels,
                           size_t sdf_padding, const void* data,
                           size_t data_size)
    : Font(name, size_in_pixels, sdf_padding), helper_(new Helper(this)) {
  if (helper_->Init(data, data_size, false)) {
    SetFontMetrics(helper_->GetFontMetrics());
  }
}

FreeTypeFont::FreeTypeFont(const std::string& name, size_t size_in_pixels,
                           size_t sdf_padding)
    : Font(name, size_in_pixels, sdf_padding), helper_(new Helper(this)) {
  helper_->Init(NULL, 0U, true);
}

FreeTypeFont::~FreeTypeFont() {}

bool FreeTypeFont::LoadGlyphGrid(GlyphIndex glyph_index,
                                 GlyphGrid* glyph_grid) const {
  return helper_->LoadGlyph(glyph_index, NULL, glyph_grid);
}

const math::Vector2f FreeTypeFont::GetKerning(CharIndex char_index0,
                                              CharIndex char_index1) const {
  return helper_->GetKerning(char_index0, char_index1);
}

#if defined(ION_USE_ICU)
void FreeTypeFont::GetFontRunsForText(icu::UnicodeString chars,
                                      iculx::FontRuns* runs) const {
  uint32 current_face = GlyphIndexToFaceId(GetDefaultGlyphForChar(chars[0]));
  for (int i = 1; i < chars.length(); ++i) {
    uint32 this_face = GlyphIndexToFaceId(GetDefaultGlyphForChar(chars[i]));
    if (this_face != current_face) {
      runs->add(helper_->GetFace(current_face), i);
      current_face = this_face;
    }
  }
  runs->add(helper_->GetFace(current_face), chars.length());
  return;
}

GlyphIndex FreeTypeFont::GlyphIndexForICUFont(
    const icu::LEFontInstance* icu_font, int32 glyph_id) const {
  return helper_->GlyphIndexForICUFont(icu_font, glyph_id);
}
#endif  // ION_USE_ICU

GlyphIndex FreeTypeFont::GetDefaultGlyphForChar(CharIndex char_index) const {
  return helper_->GetDefaultGlyphForChar(char_index);
}

const Layout FreeTypeFont::BuildLayout(const std::string& text,
                                       const LayoutOptions& options) const {
  if (text.empty() || !IsSizeValid(options.target_size)) return Layout();

  const Lines lines = base::SplitString(text, "\n");

  const TextSize text_size = ComputeTextSize(*this, options, lines);

  const FreeTypeFontTransformData transform_data =
      ComputeTransformData(*this, options, text_size);

#if defined(ION_USE_ICU)
  bool use_icu = true;
#else   // ION_USE_ICU
  bool use_icu = false;
#endif  // ION_USE_ICU

  return LayOutText(*this, use_icu, lines, transform_data);
}

void FreeTypeFont::AddFallbackFont(const FontPtr& fallback) {
  helper_->AddFallbackFace(std::weak_ptr<Helper>(
      reinterpret_cast<FreeTypeFont*>(fallback.Get())->helper_));
}

const FreeTypeFont::GlyphMetrics& FreeTypeFont::GetGlyphMetrics(
    GlyphIndex glyph_index) const {
  if (!glyph_index) {
    return base::InvalidReference<FreeTypeFont::GlyphMetrics>();
  }
  const auto& meta = helper_->GetGlyphMetaData(glyph_index);
  if (base::IsInvalidReference(meta)) {
    return base::InvalidReference<FreeTypeFont::GlyphMetrics>();
  }
  return meta.metrics;
}

}  // namespace text
}  // namespace ion