/*
 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
 *           (C) 1999 Antti Koivisto (koivisto@kde.org)
 *           (C) 2000 Dirk Mueller (mueller@kde.org)
 * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
 * Copyright (c) 2007, 2008, 2010 Google Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#include "platform/fonts/Font.h"

#include "platform/LayoutTestSupport.h"
#include "platform/LayoutUnit.h"
#include "platform/RuntimeEnabledFeatures.h"
#include "platform/fonts/CharacterRange.h"
#include "platform/fonts/FontCache.h"
#include "platform/fonts/FontFallbackIterator.h"
#include "platform/fonts/FontFallbackList.h"
#include "platform/fonts/GlyphBuffer.h"
#include "platform/fonts/GlyphPageTreeNode.h"
#include "platform/fonts/SimpleFontData.h"
#include "platform/fonts/shaping/CachingWordShaper.h"
#include "platform/fonts/shaping/HarfBuzzFace.h"
#include "platform/fonts/shaping/HarfBuzzShaper.h"
#include "platform/fonts/shaping/SimpleShaper.h"
#include "platform/geometry/FloatRect.h"
#include "platform/text/BidiResolver.h"
#include "platform/text/Character.h"
#include "platform/text/TextRun.h"
#include "platform/text/TextRunIterator.h"
#include "platform/transforms/AffineTransform.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkPaint.h"
#include "third_party/skia/include/core/SkTextBlob.h"
#include "wtf/StdLibExtras.h"
#include "wtf/text/CharacterNames.h"
#include "wtf/text/Unicode.h"

using namespace WTF;
using namespace Unicode;

namespace blink {

Font::Font() : m_canShapeWordByWord(0), m_shapeWordByWordComputed(0) {}

Font::Font(const FontDescription& fd)
    : m_fontDescription(fd),
      m_canShapeWordByWord(0),
      m_shapeWordByWordComputed(0) {}

Font::Font(const Font& other)
    : m_fontDescription(other.m_fontDescription),
      m_fontFallbackList(other.m_fontFallbackList),
      // TODO(yosin): We should have a comment the reason why don't we copy
      // |m_canShapeWordByWord| and |m_shapeWordByWordComputed| from |other|,
      // since |operator=()| copies them from |other|.
      m_canShapeWordByWord(0),
      m_shapeWordByWordComputed(0) {}

Font& Font::operator=(const Font& other) {
  m_fontDescription = other.m_fontDescription;
  m_fontFallbackList = other.m_fontFallbackList;
  m_canShapeWordByWord = other.m_canShapeWordByWord;
  m_shapeWordByWordComputed = other.m_shapeWordByWordComputed;
  return *this;
}

bool Font::operator==(const Font& other) const {
  FontSelector* first =
      m_fontFallbackList ? m_fontFallbackList->getFontSelector() : 0;
  FontSelector* second = other.m_fontFallbackList
                             ? other.m_fontFallbackList->getFontSelector()
                             : 0;

  return first == second && m_fontDescription == other.m_fontDescription &&
         (m_fontFallbackList ? m_fontFallbackList->fontSelectorVersion() : 0) ==
             (other.m_fontFallbackList
                  ? other.m_fontFallbackList->fontSelectorVersion()
                  : 0) &&
         (m_fontFallbackList ? m_fontFallbackList->generation() : 0) ==
             (other.m_fontFallbackList ? other.m_fontFallbackList->generation()
                                       : 0);
}

void Font::update(FontSelector* fontSelector) const {
  // FIXME: It is pretty crazy that we are willing to just poke into a RefPtr,
  // but it ends up being reasonably safe (because inherited fonts in the render
  // tree pick up the new style anyway. Other copies are transient, e.g., the
  // state in the GraphicsContext, and won't stick around long enough to get you
  // in trouble). Still, this is pretty disgusting, and could eventually be
  // rectified by using RefPtrs for Fonts themselves.
  if (!m_fontFallbackList)
    m_fontFallbackList = FontFallbackList::create();
  m_fontFallbackList->invalidate(fontSelector);
}

float Font::buildGlyphBuffer(const TextRunPaintInfo& runInfo,
                             GlyphBuffer& glyphBuffer,
                             const GlyphData* emphasisData) const {
  if (codePath(runInfo) == ComplexPath) {
    float width;
    CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
    if (emphasisData) {
      width = shaper.fillGlyphBufferForTextEmphasis(this, runInfo.run,
                                                    emphasisData, &glyphBuffer,
                                                    runInfo.from, runInfo.to);
    } else {
      width = shaper.fillGlyphBuffer(this, runInfo.run, nullptr, &glyphBuffer,
                                     runInfo.from, runInfo.to);
    }

    return width;
  }

  SimpleShaper shaper(this, runInfo.run, emphasisData,
                      nullptr /* fallbackFonts */, nullptr);
  shaper.advance(runInfo.from);
  shaper.advance(runInfo.to, &glyphBuffer);
  float width = shaper.runWidthSoFar();

  if (runInfo.run.rtl()) {
    // Glyphs are shaped & stored in RTL advance order - reverse them for LTR
    // drawing.
    shaper.advance(runInfo.run.length());
    glyphBuffer.reverseForSimpleRTL(width, shaper.runWidthSoFar());
  }

  return width;
}

bool Font::drawText(SkCanvas* canvas,
                    const TextRunPaintInfo& runInfo,
                    const FloatPoint& point,
                    float deviceScaleFactor,
                    const SkPaint& paint) const {
  // Don't draw anything while we are using custom fonts that are in the process
  // of loading.
  if (shouldSkipDrawing())
    return false;

  if (runInfo.cachedTextBlob && runInfo.cachedTextBlob->get()) {
    // we have a pre-cached blob -- happy joy!
    canvas->drawTextBlob(runInfo.cachedTextBlob->get(), point.x(), point.y(),
                         paint);
    return true;
  }

  GlyphBuffer glyphBuffer;
  buildGlyphBuffer(runInfo, glyphBuffer);

  drawGlyphBuffer(canvas, paint, runInfo, glyphBuffer, point,
                  deviceScaleFactor);
  return true;
}

bool Font::drawBidiText(SkCanvas* canvas,
                        const TextRunPaintInfo& runInfo,
                        const FloatPoint& point,
                        CustomFontNotReadyAction customFontNotReadyAction,
                        float deviceScaleFactor,
                        const SkPaint& paint) const {
  // Don't draw anything while we are using custom fonts that are in the process
  // of loading, except if the 'force' argument is set to true (in which case it
  // will use a fallback font).
  if (shouldSkipDrawing() &&
      customFontNotReadyAction == DoNotPaintIfFontNotReady)
    return false;

  // sub-run painting is not supported for Bidi text.
  const TextRun& run = runInfo.run;
  ASSERT((runInfo.from == 0) && (runInfo.to == run.length()));
  BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
  bidiResolver.setStatus(
      BidiStatus(run.direction(), run.directionalOverride()));
  bidiResolver.setPositionIgnoringNestedIsolates(TextRunIterator(&run, 0));

  // FIXME: This ownership should be reversed. We should pass BidiRunList
  // to BidiResolver in createBidiRunsForLine.
  BidiRunList<BidiCharacterRun>& bidiRuns = bidiResolver.runs();
  bidiResolver.createBidiRunsForLine(TextRunIterator(&run, run.length()));
  if (!bidiRuns.runCount())
    return true;

  FloatPoint currPoint = point;
  BidiCharacterRun* bidiRun = bidiRuns.firstRun();
  while (bidiRun) {
    TextRun subrun =
        run.subRun(bidiRun->start(), bidiRun->stop() - bidiRun->start());
    bool isRTL = bidiRun->level() % 2;
    subrun.setDirection(isRTL ? RTL : LTR);
    subrun.setDirectionalOverride(bidiRun->dirOverride(false));

    TextRunPaintInfo subrunInfo(subrun);
    subrunInfo.bounds = runInfo.bounds;

    // TODO: investigate blob consolidation/caching (technically,
    //       all subruns could be part of the same blob).
    GlyphBuffer glyphBuffer;
    float runWidth = buildGlyphBuffer(subrunInfo, glyphBuffer);
    drawGlyphBuffer(canvas, paint, subrunInfo, glyphBuffer, currPoint,
                    deviceScaleFactor);

    bidiRun = bidiRun->next();
    currPoint.move(runWidth, 0);
  }

  bidiRuns.deleteRuns();
  return true;
}

void Font::drawEmphasisMarks(SkCanvas* canvas,
                             const TextRunPaintInfo& runInfo,
                             const AtomicString& mark,
                             const FloatPoint& point,
                             float deviceScaleFactor,
                             const SkPaint& paint) const {
  if (shouldSkipDrawing())
    return;

  FontCachePurgePreventer purgePreventer;

  GlyphData emphasisGlyphData;
  if (!getEmphasisMarkGlyphData(mark, emphasisGlyphData))
    return;

  ASSERT(emphasisGlyphData.fontData);
  if (!emphasisGlyphData.fontData)
    return;

  GlyphBuffer glyphBuffer;
  buildGlyphBuffer(runInfo, glyphBuffer, &emphasisGlyphData);

  if (glyphBuffer.isEmpty())
    return;

  drawGlyphBuffer(canvas, paint, runInfo, glyphBuffer, point,
                  deviceScaleFactor);
}

float Font::width(const TextRun& run,
                  HashSet<const SimpleFontData*>* fallbackFonts,
                  FloatRect* glyphBounds) const {
  FontCachePurgePreventer purgePreventer;

  if (codePath(TextRunPaintInfo(run)) == ComplexPath)
    return floatWidthForComplexText(run, fallbackFonts, glyphBounds);
  return floatWidthForSimpleText(run, fallbackFonts, glyphBounds);
}

namespace {

enum BlobRotation {
  NoRotation,
  CCWRotation,
};

class GlyphBufferBloberizer {
  STACK_ALLOCATED()
 public:
  GlyphBufferBloberizer(const GlyphBuffer& buffer,
                        const Font* font,
                        float deviceScaleFactor)
      : m_buffer(buffer),
        m_font(font),
        m_deviceScaleFactor(deviceScaleFactor),
        m_hasVerticalOffsets(buffer.hasVerticalOffsets()),
        m_index(0),
        m_blobCount(0),
        m_rotation(buffer.isEmpty() ? NoRotation : computeBlobRotation(
                                                       buffer.fontDataAt(0))) {}

  bool done() const { return m_index >= m_buffer.size(); }
  unsigned blobCount() const { return m_blobCount; }

  std::pair<sk_sp<SkTextBlob>, BlobRotation> next() {
    ASSERT(!done());
    const BlobRotation currentRotation = m_rotation;

    while (m_index < m_buffer.size()) {
      const SimpleFontData* fontData = m_buffer.fontDataAt(m_index);
      ASSERT(fontData);

      const BlobRotation newRotation = computeBlobRotation(fontData);
      if (newRotation != m_rotation) {
        // We're switching to an orientation which requires a different rotation
        //   => emit the pending blob (and start a new one with the new
        //      rotation).
        m_rotation = newRotation;
        break;
      }

      const unsigned start = m_index++;
      while (m_index < m_buffer.size() &&
             m_buffer.fontDataAt(m_index) == fontData)
        m_index++;

      appendRun(start, m_index - start, fontData);
    }

    m_blobCount++;
    return std::make_pair(m_builder.make(), currentRotation);
  }

 private:
  static BlobRotation computeBlobRotation(const SimpleFontData* font) {
    // For vertical upright text we need to compensate the inherited 90deg CW
    // rotation (using a 90deg CCW rotation).
    return (font->platformData().isVerticalAnyUpright() && font->verticalData())
               ? CCWRotation
               : NoRotation;
  }

  void appendRun(unsigned start,
                 unsigned count,
                 const SimpleFontData* fontData) {
    SkPaint paint;
    fontData->platformData().setupPaint(&paint, m_deviceScaleFactor, m_font);
    paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);

    const SkTextBlobBuilder::RunBuffer& buffer =
        m_hasVerticalOffsets ? m_builder.allocRunPos(paint, count)
                             : m_builder.allocRunPosH(paint, count, 0);

    const uint16_t* glyphs = m_buffer.glyphs(start);
    const float* offsets = m_buffer.offsets(start);
    std::copy(glyphs, glyphs + count, buffer.glyphs);

    if (m_rotation == NoRotation) {
      std::copy(offsets, offsets + (m_hasVerticalOffsets ? 2 * count : count),
                buffer.pos);
    } else {
      ASSERT(m_hasVerticalOffsets);

      const float verticalBaselineXOffset =
          fontData->getFontMetrics().floatAscent() -
          fontData->getFontMetrics().floatAscent(IdeographicBaseline);

      // TODO(fmalita): why don't we apply this adjustment when building the
      // glyph buffer?
      for (unsigned i = 0; i < 2 * count; i += 2) {
        buffer.pos[i] = SkFloatToScalar(offsets[i] + verticalBaselineXOffset);
        buffer.pos[i + 1] = SkFloatToScalar(offsets[i + 1]);
      }
    }
  }

  const GlyphBuffer& m_buffer;
  const Font* m_font;
  const float m_deviceScaleFactor;
  const bool m_hasVerticalOffsets;

  SkTextBlobBuilder m_builder;
  unsigned m_index;
  unsigned m_blobCount;
  BlobRotation m_rotation;
};

}  // anonymous namespace

void Font::drawGlyphBuffer(SkCanvas* canvas,
                           const SkPaint& paint,
                           const TextRunPaintInfo& runInfo,
                           const GlyphBuffer& glyphBuffer,
                           const FloatPoint& point,
                           float deviceScaleFactor) const {
  GlyphBufferBloberizer bloberizer(glyphBuffer, this, deviceScaleFactor);
  std::pair<sk_sp<SkTextBlob>, BlobRotation> blob;

  while (!bloberizer.done()) {
    blob = bloberizer.next();
    ASSERT(blob.first);

    SkAutoCanvasRestore autoRestore(canvas, false);
    if (blob.second == CCWRotation) {
      canvas->save();

      SkMatrix m;
      m.setSinCos(-1, 0, point.x(), point.y());
      canvas->concat(m);
    }

    canvas->drawTextBlob(blob.first, point.x(), point.y(), paint);
  }

  // Cache results when
  //   1) requested by clients, and
  //   2) the glyph buffer is encoded as a single blob, and
  //   3) the blob is not upright/rotated
  if (runInfo.cachedTextBlob && bloberizer.blobCount() == 1 &&
      blob.second == NoRotation) {
    ASSERT(!*runInfo.cachedTextBlob);
    *runInfo.cachedTextBlob = std::move(blob.first);
    ASSERT(*runInfo.cachedTextBlob);
  }
}

static inline FloatRect pixelSnappedSelectionRect(FloatRect rect) {
  // Using roundf() rather than ceilf() for the right edge as a compromise to
  // ensure correct caret positioning.
  float roundedX = roundf(rect.x());
  return FloatRect(roundedX, rect.y(), roundf(rect.maxX() - roundedX),
                   rect.height());
}

FloatRect Font::selectionRectForText(const TextRun& run,
                                     const FloatPoint& point,
                                     int h,
                                     int from,
                                     int to,
                                     bool accountForGlyphBounds) const {
  to = (to == -1 ? run.length() : to);

  TextRunPaintInfo runInfo(run);
  runInfo.from = from;
  runInfo.to = to;

  FontCachePurgePreventer purgePreventer;

  if (codePath(runInfo) != ComplexPath)
    return pixelSnappedSelectionRect(selectionRectForSimpleText(
        run, point, h, from, to, accountForGlyphBounds));
  return pixelSnappedSelectionRect(
      selectionRectForComplexText(run, point, h, from, to));
}

int Font::offsetForPosition(const TextRun& run,
                            float x,
                            bool includePartialGlyphs) const {
  FontCachePurgePreventer purgePreventer;

  if (codePath(TextRunPaintInfo(run)) != ComplexPath &&
      !getFontDescription().getTypesettingFeatures())
    return offsetForPositionForSimpleText(run, x, includePartialGlyphs);

  return offsetForPositionForComplexText(run, x, includePartialGlyphs);
}

CodePath Font::codePath(const TextRunPaintInfo& runInfo) const {
  if (RuntimeEnabledFeatures::alwaysUseComplexTextEnabled() ||
      LayoutTestSupport::alwaysUseComplexTextForTest()) {
    return ComplexPath;
  }

  const TextRun& run = runInfo.run;

  if (getFontDescription().getTypesettingFeatures())
    return ComplexPath;

  if (m_fontDescription.featureSettings() &&
      m_fontDescription.featureSettings()->size() > 0)
    return ComplexPath;

  if (m_fontDescription.isVerticalBaseline())
    return ComplexPath;

  if (m_fontDescription.widthVariant() != RegularWidth)
    return ComplexPath;

  // FIXME: This really shouldn't be needed but for some reason the
  // TextRendering setting doesn't propagate to typesettingFeatures in time
  // for the prefs width calculation.
  if (getFontDescription().textRendering() == OptimizeLegibility ||
      getFontDescription().textRendering() == GeometricPrecision)
    return ComplexPath;

  if (run.is8Bit())
    return SimplePath;

  // Start from 0 since drawing and highlighting also measure the characters
  // before run->from.
  return Character::characterRangeCodePath(run.characters16(), run.length());
}

bool Font::canShapeWordByWord() const {
  if (!m_shapeWordByWordComputed) {
    m_canShapeWordByWord = computeCanShapeWordByWord();
    m_shapeWordByWordComputed = true;
  }
  return m_canShapeWordByWord;
};

bool Font::computeCanShapeWordByWord() const {
  if (!getFontDescription().getTypesettingFeatures())
    return true;

  if (!primaryFont())
    return false;

  const FontPlatformData& platformData = primaryFont()->platformData();
  TypesettingFeatures features = getFontDescription().getTypesettingFeatures();
  return !platformData.hasSpaceInLigaturesOrKerning(features);
};

void Font::willUseFontData(const String& text) const {
  const FontFamily& family = getFontDescription().family();
  if (m_fontFallbackList && m_fontFallbackList->getFontSelector() &&
      !family.familyIsEmpty())
    m_fontFallbackList->getFontSelector()->willUseFontData(
        getFontDescription(), family.family(), text);
}

static inline GlyphData glyphDataForNonCJKCharacterWithGlyphOrientation(
    UChar32 character,
    bool isUpright,
    GlyphData& data,
    unsigned pageNumber) {
  if (isUpright) {
    RefPtr<SimpleFontData> uprightFontData =
        data.fontData->uprightOrientationFontData();
    GlyphPageTreeNode* uprightNode = GlyphPageTreeNode::getNormalRootChild(
        uprightFontData.get(), pageNumber);
    GlyphPage* uprightPage = uprightNode->page();
    if (uprightPage) {
      GlyphData uprightData = uprightPage->glyphDataForCharacter(character);
      // If the glyphs are the same, then we know we can just use the horizontal
      // glyph rotated vertically to be upright.
      if (data.glyph == uprightData.glyph)
        return data;
      // The glyphs are distinct, meaning that the font has a vertical-right
      // glyph baked into it. We can't use that glyph, so we fall back to the
      // upright data and use the horizontal glyph.
      if (uprightData.fontData)
        return uprightData;
    }
  } else {
    RefPtr<SimpleFontData> verticalRightFontData =
        data.fontData->verticalRightOrientationFontData();
    GlyphPageTreeNode* verticalRightNode =
        GlyphPageTreeNode::getNormalRootChild(verticalRightFontData.get(),
                                              pageNumber);
    GlyphPage* verticalRightPage = verticalRightNode->page();
    if (verticalRightPage) {
      GlyphData verticalRightData =
          verticalRightPage->glyphDataForCharacter(character);
      // If the glyphs are distinct, we will make the assumption that the font
      // has a vertical-right glyph baked into it.
      if (data.glyph != verticalRightData.glyph)
        return data;
      // The glyphs are identical, meaning that we should just use the
      // horizontal glyph.
      if (verticalRightData.fontData)
        return verticalRightData;
    }
  }
  return data;
}

PassRefPtr<FontFallbackIterator> Font::createFontFallbackIterator(
    FontFallbackPriority fallbackPriority) const {
  return FontFallbackIterator::create(m_fontDescription, m_fontFallbackList,
                                      fallbackPriority);
}

GlyphData Font::glyphDataForCharacter(UChar32& c,
                                      bool mirror,
                                      bool normalizeSpace,
                                      FontDataVariant variant) const {
  ASSERT(isMainThread());

  if (variant == AutoVariant) {
    if (m_fontDescription.variantCaps() == FontDescription::SmallCaps) {
      UChar32 upperC =
          toUpper(c, LayoutLocale::localeString(m_fontDescription.locale()));
      if (upperC != c) {
        c = upperC;
        variant = SmallCapsVariant;
      } else {
        variant = NormalVariant;
      }
    } else {
      variant = NormalVariant;
    }
  }

  if (normalizeSpace && Character::isNormalizedCanvasSpaceCharacter(c))
    c = spaceCharacter;

  if (mirror)
    c = mirroredChar(c);

  unsigned pageNumber = (c / GlyphPage::size);

  GlyphPageTreeNodeBase* node = m_fontFallbackList->getPageNode(pageNumber);
  if (!node) {
    node = GlyphPageTreeNode::getRootChild(fontDataAt(0), pageNumber);
    m_fontFallbackList->setPageNode(pageNumber, node);
  }
  RELEASE_ASSERT(node);  // Diagnosing crbug.com/446566 crash bug.

  GlyphPage* page = 0;
  if (variant == NormalVariant) {
    // Fastest loop, for the common case (normal variant).
    while (true) {
      page = node->page(m_fontDescription.script());
      if (page) {
        GlyphData data = page->glyphDataForCharacter(c);
        if (data.fontData) {
          if (!data.fontData->platformData().isVerticalAnyUpright() ||
              data.fontData->isTextOrientationFallback())
            return data;

          bool isUpright = m_fontDescription.isVerticalUpright(c);
          if (!isUpright || !Character::isCJKIdeographOrSymbol(c))
            return glyphDataForNonCJKCharacterWithGlyphOrientation(
                c, isUpright, data, pageNumber);

          return data;
        }

        if (node->isSystemFallback())
          break;
      }

      // Proceed with the fallback list.
      node = toGlyphPageTreeNode(node)->getChild(fontDataAt(node->level()),
                                                 pageNumber);
      m_fontFallbackList->setPageNode(pageNumber, node);
    }
  }
  if (variant != NormalVariant) {
    while (true) {
      page = node->page(m_fontDescription.script());
      if (page) {
        GlyphData data = page->glyphDataForCharacter(c);
        if (data.fontData) {
          // The variantFontData function should not normally return 0.
          // But if it does, we will just render the capital letter big.
          RefPtr<SimpleFontData> variantFontData =
              data.fontData->variantFontData(m_fontDescription, variant);
          if (!variantFontData)
            return data;

          GlyphPageTreeNode* variantNode =
              GlyphPageTreeNode::getNormalRootChild(variantFontData.get(),
                                                    pageNumber);
          GlyphPage* variantPage = variantNode->page();
          if (variantPage) {
            GlyphData data = variantPage->glyphDataForCharacter(c);
            if (data.fontData)
              return data;
          }

          // Do not attempt system fallback off the variantFontData. This is the
          // very unlikely case that a font has the lowercase character but the
          // small caps font does not have its uppercase version.
          return variantFontData->missingGlyphData();
        }

        if (node->isSystemFallback())
          break;
      }

      // Proceed with the fallback list.
      node = toGlyphPageTreeNode(node)->getChild(fontDataAt(node->level()),
                                                 pageNumber);
      m_fontFallbackList->setPageNode(pageNumber, node);
    }
  }

  ASSERT(page);
  ASSERT(node->isSystemFallback());

  // System fallback is character-dependent. When we get here, we
  // know that the character in question isn't in the system fallback
  // font's glyph page. Try to lazily create it here.

  // FIXME: Unclear if this should normalizeSpaces above 0xFFFF.
  // Doing so changes fast/text/international/plane2-diffs.html
  UChar32 characterToRender = c;
  if (characterToRender <= 0xFFFF)
    characterToRender = Character::normalizeSpaces(characterToRender);

  const FontData* fontData = fontDataAt(0);
  if (fontData) {
    const SimpleFontData* fontDataToSubstitute =
        fontData->fontDataForCharacter(characterToRender);
    RefPtr<SimpleFontData> characterFontData =
        FontCache::fontCache()->fallbackFontForCharacter(
            m_fontDescription, characterToRender, fontDataToSubstitute);
    if (characterFontData && variant != NormalVariant) {
      characterFontData =
          characterFontData->variantFontData(m_fontDescription, variant);
    }
    if (characterFontData) {
      // Got the fallback glyph and font.
      unsigned pageNumberForRendering = characterToRender / GlyphPage::size;
      GlyphPage* fallbackPage =
          GlyphPageTreeNode::getRootChild(characterFontData.get(),
                                          pageNumberForRendering)
              ->page();
      GlyphData data =
          fallbackPage && fallbackPage->glyphForCharacter(characterToRender)
              ? fallbackPage->glyphDataForCharacter(characterToRender)
              : characterFontData->missingGlyphData();
      // Cache it so we don't have to do system fallback again next time.
      if (variant == NormalVariant) {
        page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
        data.fontData->setMaxGlyphPageTreeLevel(
            std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
        if (data.fontData->platformData().isVerticalAnyUpright() &&
            !data.fontData->isTextOrientationFallback() &&
            !Character::isCJKIdeographOrSymbol(characterToRender))
          return glyphDataForNonCJKCharacterWithGlyphOrientation(
              characterToRender,
              m_fontDescription.isVerticalUpright(characterToRender), data,
              pageNumberForRendering);
      }
      return data;
    }
  }

  // Even system fallback can fail; use the missing glyph in that case.
  // FIXME: It would be nicer to use the missing glyph from the last resort font
  // instead.
  ASSERT(primaryFont());
  GlyphData data = primaryFont()->missingGlyphData();
  if (variant == NormalVariant) {
    page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
    data.fontData->setMaxGlyphPageTreeLevel(
        std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
  }
  return data;
}

bool Font::getEmphasisMarkGlyphData(const AtomicString& mark,
                                    GlyphData& glyphData) const {
  if (mark.isEmpty())
    return false;

  TextRun emphasisMarkRun(mark, mark.length());
  TextRunPaintInfo emphasisPaintInfo(emphasisMarkRun);
  GlyphBuffer glyphBuffer;
  buildGlyphBuffer(emphasisPaintInfo, glyphBuffer);

  if (glyphBuffer.isEmpty())
    return false;

  ASSERT(glyphBuffer.fontDataAt(0));
  glyphData.fontData =
      glyphBuffer.fontDataAt(0)->emphasisMarkFontData(m_fontDescription).get();
  glyphData.glyph = glyphBuffer.glyphAt(0);

  return true;
}

int Font::emphasisMarkAscent(const AtomicString& mark) const {
  FontCachePurgePreventer purgePreventer;

  GlyphData markGlyphData;
  if (!getEmphasisMarkGlyphData(mark, markGlyphData))
    return 0;

  const SimpleFontData* markFontData = markGlyphData.fontData;
  ASSERT(markFontData);
  if (!markFontData)
    return 0;

  return markFontData->getFontMetrics().ascent();
}

int Font::emphasisMarkDescent(const AtomicString& mark) const {
  FontCachePurgePreventer purgePreventer;

  GlyphData markGlyphData;
  if (!getEmphasisMarkGlyphData(mark, markGlyphData))
    return 0;

  const SimpleFontData* markFontData = markGlyphData.fontData;
  ASSERT(markFontData);
  if (!markFontData)
    return 0;

  return markFontData->getFontMetrics().descent();
}

int Font::emphasisMarkHeight(const AtomicString& mark) const {
  FontCachePurgePreventer purgePreventer;

  GlyphData markGlyphData;
  if (!getEmphasisMarkGlyphData(mark, markGlyphData))
    return 0;

  const SimpleFontData* markFontData = markGlyphData.fontData;
  ASSERT(markFontData);
  if (!markFontData)
    return 0;

  return markFontData->getFontMetrics().height();
}

float Font::floatWidthForComplexText(
    const TextRun& run,
    HashSet<const SimpleFontData*>* fallbackFonts,
    FloatRect* glyphBounds) const {
  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
  float width = shaper.width(this, run, fallbackFonts, glyphBounds);
  return width;
}

// Return the code point index for the given |x| offset into the text run.
int Font::offsetForPositionForComplexText(const TextRun& run,
                                          float xFloat,
                                          bool includePartialGlyphs) const {
  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
  return shaper.offsetForPosition(this, run, xFloat, includePartialGlyphs);
}

// Return the rectangle for selecting the given range of code-points in the
// TextRun.
FloatRect Font::selectionRectForComplexText(const TextRun& run,
                                            const FloatPoint& point,
                                            int height,
                                            int from,
                                            int to) const {
  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
  CharacterRange range = shaper.getCharacterRange(this, run, from, to);
  return FloatRect(point.x() + range.start, point.y(), range.width(), height);
}

CharacterRange Font::getCharacterRange(const TextRun& run,
                                       unsigned from,
                                       unsigned to) const {
  FontCachePurgePreventer purgePreventer;
  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
  return shaper.getCharacterRange(this, run, from, to);
}

Vector<CharacterRange> Font::individualCharacterRanges(
    const TextRun& run) const {
  // TODO(pdr): Android is temporarily (crbug.com/577306) using the old simple
  // shaper and using the complex shaper here can show differences between
  // the two shapers. This function is currently only called through SVG
  // which now exclusively uses the complex shaper, so the primary difference
  // will be improved shaping in SVG when compared to HTML.
  FontCachePurgePreventer purgePreventer;
  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
  auto ranges = shaper.individualCharacterRanges(this, run);
  // The shaper should return ranges.size == run.length but on some platforms
  // (OSX10.9.5) we are seeing cases in the upper end of the unicode range
  // where this is not true (see: crbug.com/620952). To catch these cases on
  // more popular platforms, and to protect users, we are using a CHECK here.
  CHECK_EQ(ranges.size(), run.length());
  return ranges;
}

float Font::floatWidthForSimpleText(
    const TextRun& run,
    HashSet<const SimpleFontData*>* fallbackFonts,
    FloatRect* glyphBounds) const {
  SimpleShaper shaper(this, run, nullptr, fallbackFonts, glyphBounds);
  shaper.advance(run.length());
  return shaper.runWidthSoFar();
}

FloatRect Font::selectionRectForSimpleText(const TextRun& run,
                                           const FloatPoint& point,
                                           int h,
                                           int from,
                                           int to,
                                           bool accountForGlyphBounds) const {
  FloatRect bounds;
  SimpleShaper shaper(this, run, nullptr, nullptr,
                      accountForGlyphBounds ? &bounds : nullptr);
  shaper.advance(from);
  float fromX = shaper.runWidthSoFar();
  shaper.advance(to);
  float toX = shaper.runWidthSoFar();

  if (run.rtl()) {
    shaper.advance(run.length());
    float totalWidth = shaper.runWidthSoFar();
    float beforeWidth = fromX;
    float afterWidth = toX;
    fromX = totalWidth - afterWidth;
    toX = totalWidth - beforeWidth;
  }

  return FloatRect(point.x() + fromX,
                   accountForGlyphBounds ? bounds.y() : point.y(), toX - fromX,
                   accountForGlyphBounds ? bounds.maxY() - bounds.y() : h);
}

int Font::offsetForPositionForSimpleText(const TextRun& run,
                                         float x,
                                         bool includePartialGlyphs) const {
  float delta = x;

  SimpleShaper shaper(this, run);
  unsigned offset;
  if (run.rtl()) {
    delta -= floatWidthForSimpleText(run);
    while (1) {
      offset = shaper.currentOffset();
      float w;
      if (!shaper.advanceOneCharacter(w))
        break;
      delta += w;
      if (includePartialGlyphs) {
        if (delta - w / 2 >= 0)
          break;
      } else {
        if (delta >= 0)
          break;
      }
    }
  } else {
    while (1) {
      offset = shaper.currentOffset();
      float w;
      if (!shaper.advanceOneCharacter(w))
        break;
      delta -= w;
      if (includePartialGlyphs) {
        if (delta + w / 2 <= 0)
          break;
      } else {
        if (delta <= 0)
          break;
      }
    }
  }

  return offset;
}

bool Font::loadingCustomFonts() const {
  return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
}

bool Font::isFallbackValid() const {
  return !m_fontFallbackList || m_fontFallbackList->isValid();
}

}  // namespace blink