Revert "Remove unique glyph IDs from glyph runs"
This reverts commit 2d123ad73f85f821c49961c0205f20d53e810cc8.
Reason for revert: Android roll?
Original change's description:
> Remove unique glyph IDs from glyph runs
>
> The unique calculation is to costly to do for SkTextBlobs every
> time because there may be a cache hit in the GrTextBlob cache.
> In the future I will move the unique ID calculation to the GrTextBlob
> creation.
>
> Change-Id: I7e10e8f22a3bc729fab12b2cf7e9732441be7f31
> Reviewed-on: https://skia-review.googlesource.com/c/164623
> Reviewed-by: Mike Klein <mtklein@google.com>
> Commit-Queue: Herb Derby <herb@google.com>
TBR=mtklein@google.com,herb@google.com
Change-Id: I8424e12e1ad1abd9e40699aa34e1062f5c7bf94a
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/c/165060
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>
diff --git a/src/core/SkGlyphRun.cpp b/src/core/SkGlyphRun.cpp
index ec5479c..9ae21c0 100644
--- a/src/core/SkGlyphRun.cpp
+++ b/src/core/SkGlyphRun.cpp
@@ -30,12 +30,16 @@
// -- SkGlyphRun -----------------------------------------------------------------------------------
SkGlyphRun::SkGlyphRun(const SkPaint& basePaint,
const SkRunFont& runFont,
+ SkSpan<const uint16_t> denseIndices,
SkSpan<const SkPoint> positions,
SkSpan<const SkGlyphID> glyphIDs,
+ SkSpan<const SkGlyphID> uniqueGlyphIDs,
SkSpan<const char> text,
SkSpan<const uint32_t> clusters)
- : fPositions{positions}
+ : fUniqueGlyphIDIndices{denseIndices}
+ , fPositions{positions}
, fGlyphIDs{glyphIDs}
+ , fUniqueGlyphIDs{uniqueGlyphIDs}
, fText{text}
, fClusters{clusters}
, fRunPaint{basePaint, runFont} {}
@@ -46,8 +50,10 @@
SkGlyphRun run{
fRunPaint,
SkRunFont{fRunPaint},
+ SkSpan<const uint16_t>{}, // No dense indices for now.
SkSpan<const SkPoint>{&point, 1},
SkSpan<const SkGlyphID>{&glyphID, 1},
+ SkSpan<const SkGlyphID>{},
SkSpan<const char>{},
SkSpan<const uint32_t>{}
};
@@ -192,6 +198,8 @@
SkRunFont{paint},
glyphIDs,
positions,
+ SkSpan<const uint16_t>{}, // no dense indices for now.,
+ SkSpan<const SkGlyphID>{},
SkSpan<const char>{},
SkSpan<const uint32_t>{});
this->makeGlyphRunList(paint, nullptr, SkPoint::Make(0, 0));
@@ -202,7 +210,8 @@
auto glyphIDs = textToGlyphIDs(paint, bytes, byteLength);
if (!glyphIDs.empty()) {
this->initialize(glyphIDs.size());
- this->simplifyDrawText(paint, SkRunFont{paint}, glyphIDs, origin, fPositions);
+ this->simplifyDrawText(paint, SkRunFont{paint}, glyphIDs, origin,
+ fUniqueGlyphIDIndices, fUniqueGlyphIDs, fPositions);
}
this->makeGlyphRunList(paint, nullptr, SkPoint::Make(0, 0));
@@ -215,7 +224,8 @@
if (!glyphIDs.empty()) {
this->initialize(glyphIDs.size());
this->simplifyDrawPosTextH(
- paint, SkRunFont{paint}, glyphIDs, xpos, constY, fPositions);
+ paint, SkRunFont{paint}, glyphIDs, xpos, constY,
+ fUniqueGlyphIDIndices, fUniqueGlyphIDs, fPositions);
}
this->makeGlyphRunList(paint, nullptr, SkPoint::Make(0, 0));
@@ -226,7 +236,8 @@
auto glyphIDs = textToGlyphIDs(paint, bytes, byteLength);
if (!glyphIDs.empty()) {
this->initialize(glyphIDs.size());
- this->simplifyDrawPosText(paint, SkRunFont{paint}, glyphIDs, pos);
+ this->simplifyDrawPosText(paint, SkRunFont{paint}, glyphIDs, pos,
+ fUniqueGlyphIDIndices, fUniqueGlyphIDs);
}
this->makeGlyphRunList(paint, nullptr, SkPoint::Make(0, 0));
@@ -242,7 +253,9 @@
// Pre-size all the buffers so they don't move during processing.
this->initialize(totalGlyphs);
+ uint16_t* currentDenseIndices = fUniqueGlyphIDIndices;
SkPoint* currentPositions = fPositions;
+ SkGlyphID* currentUniqueGlyphIDs = fUniqueGlyphIDs;
for (SkTextBlobRunIterator it(&blob); !it.done(); it.next()) {
// applyFontToPaint() always overwrites the exact same attributes,
@@ -254,28 +267,34 @@
const SkPoint& offset = it.offset();
auto glyphIDs = SkSpan<const SkGlyphID>{it.glyphs(), runSize};
+ size_t uniqueGlyphIDsSize = 0;
switch (it.positioning()) {
case SkTextBlobRunIterator::kDefault_Positioning: {
- this->simplifyDrawText(
- paint, it.runFont(), glyphIDs, offset, currentPositions,
+ uniqueGlyphIDsSize = this->simplifyDrawText(
+ paint, it.runFont(), glyphIDs, offset,
+ currentDenseIndices, currentUniqueGlyphIDs, currentPositions,
text, clusters);
}
break;
case SkTextBlobRunIterator::kHorizontal_Positioning: {
auto constY = offset.y();
- this->simplifyDrawPosTextH(
- paint, it.runFont(), glyphIDs, it.pos(), constY, currentPositions,
+ uniqueGlyphIDsSize = this->simplifyDrawPosTextH(
+ paint, it.runFont(), glyphIDs, it.pos(), constY,
+ currentDenseIndices, currentUniqueGlyphIDs, currentPositions,
text, clusters);
}
break;
case SkTextBlobRunIterator::kFull_Positioning:
- this->simplifyDrawPosText(
+ uniqueGlyphIDsSize = this->simplifyDrawPosText(
paint, it.runFont(), glyphIDs, (const SkPoint*)it.pos(),
+ currentDenseIndices, currentUniqueGlyphIDs,
text, clusters);
break;
}
+ currentDenseIndices += runSize;
currentPositions += runSize;
+ currentUniqueGlyphIDs += uniqueGlyphIDsSize;
}
this->makeGlyphRunList(paint, &blob, origin);
@@ -285,7 +304,8 @@
const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs, const SkPoint* pos) {
if (!glyphIDs.empty()) {
this->initialize(glyphIDs.size());
- this->simplifyDrawPosText(paint, SkRunFont{paint}, glyphIDs, pos);
+ this->simplifyDrawPosText(paint, SkRunFont{paint}, glyphIDs, pos,
+ fUniqueGlyphIDIndices, fUniqueGlyphIDs);
this->makeGlyphRunList(paint, nullptr, SkPoint::Make(0, 0));
}
}
@@ -298,7 +318,9 @@
if (totalRunSize > fMaxTotalRunSize) {
fMaxTotalRunSize = totalRunSize;
+ fUniqueGlyphIDIndices.reset(fMaxTotalRunSize);
fPositions.reset(fMaxTotalRunSize);
+ fUniqueGlyphIDs.reset(fMaxTotalRunSize);
}
fGlyphRunListStorage.clear();
@@ -324,11 +346,33 @@
}
}
+SkSpan<const SkGlyphID> SkGlyphRunBuilder::addDenseAndUnique(
+ const SkPaint& paint,
+ SkSpan<const SkGlyphID> glyphIDs,
+ uint16_t* uniqueGlyphIDIndices,
+ SkGlyphID* uniqueGlyphIDs) {
+ SkSpan<const SkGlyphID> uniquifiedGlyphIDs;
+ if (!glyphIDs.empty()) {
+ auto typeface = SkPaintPriv::GetTypefaceOrDefault(paint);
+ auto glyphUniverseSize = typeface->countGlyphs();
+
+ // There better be glyphs in the font if we want to uniqify.
+ if (glyphUniverseSize > 0) {
+ uniquifiedGlyphIDs = fGlyphIDSet.uniquifyGlyphIDs(
+ glyphUniverseSize, glyphIDs, uniqueGlyphIDs, uniqueGlyphIDIndices);
+ }
+ }
+
+ return uniquifiedGlyphIDs;
+}
+
void SkGlyphRunBuilder::makeGlyphRun(
const SkPaint& basePaint,
const SkRunFont& runFont,
SkSpan<const SkGlyphID> glyphIDs,
SkSpan<const SkPoint> positions,
+ SkSpan<const uint16_t> uniqueGlyphIDIndices,
+ SkSpan<const SkGlyphID> uniqueGlyphIDs,
SkSpan<const char> text,
SkSpan<const uint32_t> clusters) {
@@ -337,8 +381,10 @@
fGlyphRunListStorage.emplace_back(
basePaint,
runFont,
+ uniqueGlyphIDIndices,
positions,
glyphIDs,
+ uniqueGlyphIDs,
text,
clusters);
}
@@ -352,53 +398,62 @@
paint, blob, origin, SkSpan<SkGlyphRun>{fGlyphRunListStorage}};
}
-SkPoint SkGlyphRunBuilder::simplifyDrawText(
+size_t SkGlyphRunBuilder::simplifyDrawText(
const SkPaint& paint, const SkRunFont& runFont, SkSpan<const SkGlyphID> glyphIDs,
- SkPoint origin, SkPoint* positions,
- SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
+ SkPoint origin, uint16_t* uniqueGlyphIDIndicesBuffer, SkGlyphID* uniqueGlyphIDsBuffer,
+ SkPoint* positions, SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
SkASSERT(!glyphIDs.empty());
auto runSize = glyphIDs.size();
SkPaint runPaint{paint, runFont};
- fScratchAdvances.resize(runSize);
- {
- auto cache = SkStrikeCache::FindOrCreateStrikeExclusive(runPaint);
- cache->getAdvances(glyphIDs, fScratchAdvances.data());
- }
+ auto unqiueGlyphIDs = this->addDenseAndUnique(
+ runPaint, glyphIDs, uniqueGlyphIDIndicesBuffer, uniqueGlyphIDsBuffer);
- SkPoint endOfLastGlyph = origin;
-
- for (size_t i = 0; i < runSize; i++) {
- positions[i] = endOfLastGlyph;
- endOfLastGlyph += fScratchAdvances[i];
- }
-
- if (paint.getTextAlign() != SkPaint::kLeft_Align) {
- SkVector len = endOfLastGlyph - origin;
- if (paint.getTextAlign() == SkPaint::kCenter_Align) {
- len.scale(SK_ScalarHalf);
+ if (!unqiueGlyphIDs.empty()) {
+ fScratchAdvances.resize(runSize);
+ {
+ auto cache = SkStrikeCache::FindOrCreateStrikeExclusive(runPaint);
+ cache->getAdvances(unqiueGlyphIDs, fScratchAdvances.data());
}
- for (auto& pt : SkSpan<SkPoint>{positions, runSize}) {
- pt -= len;
+
+ SkPoint endOfLastGlyph = origin;
+
+ for (size_t i = 0; i < runSize; i++) {
+ positions[i] = endOfLastGlyph;
+ endOfLastGlyph += fScratchAdvances[uniqueGlyphIDIndicesBuffer[i]];
}
+
+ if (paint.getTextAlign() != SkPaint::kLeft_Align) {
+ SkVector len = endOfLastGlyph - origin;
+ if (paint.getTextAlign() == SkPaint::kCenter_Align) {
+ len.scale(SK_ScalarHalf);
+ }
+ for (auto& pt : SkSpan<SkPoint>{positions, runSize}) {
+ pt -= len;
+ }
+
+ }
+
+ this->makeGlyphRun(
+ paint,
+ runFont,
+ glyphIDs,
+ SkSpan<const SkPoint>{positions, runSize},
+ SkSpan<const uint16_t>{uniqueGlyphIDIndicesBuffer, runSize},
+ unqiueGlyphIDs,
+ text,
+ clusters);
}
- this->makeGlyphRun(
- paint,
- runFont,
- glyphIDs,
- SkSpan<const SkPoint>{positions, runSize},
- text,
- clusters);
-
- return endOfLastGlyph;
+ return unqiueGlyphIDs.size();
}
-void SkGlyphRunBuilder::simplifyDrawPosTextH(
+size_t SkGlyphRunBuilder::simplifyDrawPosTextH(
const SkPaint& paint, const SkRunFont& runFont, SkSpan<const SkGlyphID> glyphIDs,
- const SkScalar* xpos, SkScalar constY, SkPoint* positions,
+ const SkScalar* xpos, SkScalar constY,
+ uint16_t* uniqueGlyphIDIndicesBuffer, SkGlyphID* uniqueGlyphIDsBuffer, SkPoint* positions,
SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
auto posCursor = positions;
@@ -406,19 +461,34 @@
*posCursor++ = SkPoint::Make(x, constY);
}
- simplifyDrawPosText(paint, runFont, glyphIDs, positions, text, clusters);
+ return simplifyDrawPosText(paint, runFont, glyphIDs, positions,
+ uniqueGlyphIDIndicesBuffer, uniqueGlyphIDsBuffer,
+ text, clusters);
}
-void SkGlyphRunBuilder::simplifyDrawPosText(
+size_t SkGlyphRunBuilder::simplifyDrawPosText(
const SkPaint& paint, const SkRunFont& runFont, SkSpan<const SkGlyphID> glyphIDs,
- const SkPoint* pos, SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
+ const SkPoint* pos, uint16_t* uniqueGlyphIDIndicesBuffer, SkGlyphID* uniqueGlyphIDsBuffer,
+ SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
auto runSize = glyphIDs.size();
+ // The dense indices are not used by the rest of the stack yet.
+ SkSpan<const SkGlyphID> uniqueGlyphIDs;
+ #ifdef SK_DEBUG
+ uniqueGlyphIDs = this->addDenseAndUnique(
+ paint, glyphIDs, uniqueGlyphIDIndicesBuffer, uniqueGlyphIDsBuffer);
+ #endif
+
+ // TODO: when using the unique glyph system have a guard that there are actually glyphs like
+ // drawText above.
this->makeGlyphRun(
paint,
runFont,
glyphIDs,
SkSpan<const SkPoint>{pos, runSize},
+ SkSpan<const SkGlyphID>{uniqueGlyphIDIndicesBuffer, runSize},
+ uniqueGlyphIDs,
text,
clusters);
+ return uniqueGlyphIDs.size();
}
diff --git a/src/core/SkGlyphRun.h b/src/core/SkGlyphRun.h
index d5abb6a..2d0d345 100644
--- a/src/core/SkGlyphRun.h
+++ b/src/core/SkGlyphRun.h
@@ -87,8 +87,10 @@
SkGlyphRun() = default;
SkGlyphRun(const SkPaint& basePaint,
const SkRunFont& runFont,
+ SkSpan<const uint16_t> denseIndices,
SkSpan<const SkPoint> positions,
SkSpan<const SkGlyphID> glyphIDs,
+ SkSpan<const SkGlyphID> uniqueGlyphIDs,
SkSpan<const char> text,
SkSpan<const uint32_t> clusters);
@@ -105,17 +107,21 @@
size_t runSize() const { return fGlyphIDs.size(); }
SkSpan<const SkPoint> positions() const { return fPositions.toConst(); }
- SkSpan<const SkGlyphID> glyphsIDs() const { return fGlyphIDs; }
+ SkSpan<const SkGlyphID> shuntGlyphsIDs() const { return fGlyphIDs; }
const SkPaint& paint() const { return fRunPaint; }
SkPaint* mutablePaint() { return &fRunPaint; }
SkSpan<const uint32_t> clusters() const { return fClusters; }
SkSpan<const char> text() const { return fText; }
private:
- // Positions relative to the list's origin.
+ //
+ const SkSpan<const uint16_t> fUniqueGlyphIDIndices;
+ //
const SkSpan<const SkPoint> fPositions;
// This is temporary while converting from the old per glyph code to the bulk code.
const SkSpan<const SkGlyphID> fGlyphIDs;
+ // The unique glyphs from fGlyphIDs.
+ const SkSpan<const SkGlyphID> fUniqueGlyphIDs;
// Original text from SkTextBlob if present. Will be empty of not present.
const SkSpan<const char> fText;
// Original clusters from SkTextBlob if present. Will be empty if not present.
@@ -134,7 +140,6 @@
public:
SkGlyphRunList();
-
// Blob maybe null.
SkGlyphRunList(
const SkPaint& paint,
@@ -203,45 +208,61 @@
SkSpan<const SkGlyphID> textToGlyphIDs(
const SkPaint& paint, const void* bytes, size_t byteLength);
+ // Returns the span of unique glyph IDs.
+ SkSpan<const SkGlyphID> addDenseAndUnique(
+ const SkPaint& paint,
+ SkSpan<const SkGlyphID> glyphIDs,
+ uint16_t* uniqueGlyphIDIndices,
+ SkGlyphID* uniqueGlyphIDs);
+
void makeGlyphRun(
const SkPaint& basePaint,
const SkRunFont& runFont,
SkSpan<const SkGlyphID> glyphIDs,
SkSpan<const SkPoint> positions,
+ SkSpan<const uint16_t> uniqueGlyphIDIndices,
+ SkSpan<const SkGlyphID> uniqueGlyphIDs,
SkSpan<const char> text,
SkSpan<const uint32_t> clusters);
void makeGlyphRunList(const SkPaint& paint, const SkTextBlob* blob, SkPoint origin);
- // Return the end of the last glyph for measurement.
- SkPoint simplifyDrawText(
+ size_t simplifyDrawText(
const SkPaint& paint, const SkRunFont& runFont, SkSpan<const SkGlyphID> glyphIDs,
- SkPoint origin, SkPoint* positions,
+ SkPoint origin,uint16_t* uniqueGlyphIDIndices, SkGlyphID* uniqueGlyphIDs,
+ SkPoint* positions,
SkSpan<const char> text = SkSpan<const char>{},
SkSpan<const uint32_t> clusters = SkSpan<const uint32_t>{});
- void simplifyDrawPosTextH(
+ size_t simplifyDrawPosTextH(
const SkPaint& paint, const SkRunFont& runFont, SkSpan<const SkGlyphID> glyphIDs,
- const SkScalar* xpos, SkScalar constY, SkPoint* positions,
+ const SkScalar* xpos, SkScalar constY,
+ uint16_t* uniqueGlyphIDIndices, SkGlyphID* uniqueGlyphIDs, SkPoint* positions,
SkSpan<const char> text = SkSpan<const char>{},
SkSpan<const uint32_t> clusters = SkSpan<const uint32_t>{});
- void simplifyDrawPosText(
+ size_t simplifyDrawPosText(
const SkPaint& paint, const SkRunFont& runFont, SkSpan<const SkGlyphID> glyphIDs,
- const SkPoint* pos,
+ const SkPoint* pos, uint16_t* uniqueGlyphIDIndices, SkGlyphID* uniqueGlyphIDs,
SkSpan<const char> text = SkSpan<const char>{},
SkSpan<const uint32_t> clusters = SkSpan<const uint32_t>{});
size_t fMaxTotalRunSize{0};
+ SkAutoTMalloc<uint16_t> fUniqueGlyphIDIndices;
SkAutoTMalloc<SkPoint> fPositions;
+ SkAutoTMalloc<SkGlyphID> fUniqueGlyphIDs;
std::vector<SkGlyphRun> fGlyphRunListStorage;
SkGlyphRunList fGlyphRunList;
+
// Used as a temporary for preparing using utfN text. This implies that only one run of
// glyph ids will ever be needed because blobs are already glyph based.
std::vector<SkGlyphID> fScratchGlyphIDs;
// Used as temporary storage for calculating positions for drawText.
std::vector<SkPoint> fScratchAdvances;
+
+ // Used for collecting the set of unique glyphs.
+ SkGlyphIDSet fGlyphIDSet;
};
template <typename PerGlyphPos>
diff --git a/src/core/SkGlyphRunPainter.cpp b/src/core/SkGlyphRunPainter.cpp
index 44c94c0..cfaafe3 100644
--- a/src/core/SkGlyphRunPainter.cpp
+++ b/src/core/SkGlyphRunPainter.cpp
@@ -153,7 +153,7 @@
matrix.mapPoints(fPositions, glyphRun.positions().data(), runSize);
const SkPoint* positionCursor = fPositions;
- for (auto glyphID : glyphRun.glyphsIDs()) {
+ for (auto glyphID : glyphRun.shuntGlyphsIDs()) {
auto position = *positionCursor++;
if (SkScalarsAreFinite(position.fX, position.fY)) {
const SkGlyph& glyph = cache->getGlyphMetrics(glyphID, position);
@@ -181,7 +181,7 @@
matrix.mapPoints(fPositions, glyphRun.positions().data(), runSize);
const SkPoint* positionCursor = fPositions;
- for (auto glyphID : glyphRun.glyphsIDs()) {
+ for (auto glyphID : glyphRun.shuntGlyphsIDs()) {
auto position = *positionCursor++;
if (SkScalarsAreFinite(position.fX, position.fY)) {
const SkGlyph& glyph = cache->getGlyphIDMetrics(glyphID);
diff --git a/src/core/SkGlyphRunPainter.h b/src/core/SkGlyphRunPainter.h
index 7840604..3e7129a 100644
--- a/src/core/SkGlyphRunPainter.h
+++ b/src/core/SkGlyphRunPainter.h
@@ -150,7 +150,7 @@
mapping.mapPoints(fPositions, glyphRun.positions().data(), runSize);
const SkPoint* mappedPtCursor = fPositions;
const SkPoint* ptCursor = glyphRun.positions().data();
- for (auto glyphID : glyphRun.glyphsIDs()) {
+ for (auto glyphID : glyphRun.shuntGlyphsIDs()) {
auto mappedPt = *mappedPtCursor++;
auto pt = origin + *ptCursor++;
if (SkScalarsAreFinite(mappedPt.x(), mappedPt.y())) {
@@ -234,7 +234,7 @@
SkScalar maxFallbackDimension{-SK_ScalarInfinity};
const SkPoint* positionCursor = glyphRun.positions().data();
- for (auto glyphID : glyphRun.glyphsIDs()) {
+ for (auto glyphID : glyphRun.shuntGlyphsIDs()) {
const SkGlyph& glyph = cache->getGlyphMetrics(glyphID, {0, 0});
SkPoint glyphPos = origin + *positionCursor++;
if (glyph.fMaskFormat == SkMask::kSDF_Format || glyph.isEmpty()) {
diff --git a/src/pdf/SkClusterator.cpp b/src/pdf/SkClusterator.cpp
index 2827810..f575407 100644
--- a/src/pdf/SkClusterator.cpp
+++ b/src/pdf/SkClusterator.cpp
@@ -28,7 +28,7 @@
SkClusterator::SkClusterator(const SkGlyphRun& run)
: fClusters(run.clusters().data())
, fUtf8Text(run.text().data())
- , fGlyphCount(SkToU32(run.glyphsIDs().size()))
+ , fGlyphCount(SkToU32(run.shuntGlyphsIDs().size()))
, fTextByteLength(SkToU32(run.text().size()))
{
if (fClusters) {
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 20bbcdd..4415c34 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -1038,8 +1038,8 @@
SkPath path;
SkASSERT(paint.getTextEncoding() == SkPaint::kGlyphID_TextEncoding);
- paint.getPosTextPath(glyphRun.glyphsIDs().data(),
- glyphRun.glyphsIDs().size() * sizeof(SkGlyphID),
+ paint.getPosTextPath(glyphRun.shuntGlyphsIDs().data(),
+ glyphRun.shuntGlyphsIDs().size() * sizeof(SkGlyphID),
glyphRun.positions().data(),
&path);
path.offset(offset.x(), offset.y());
@@ -1088,8 +1088,8 @@
void SkPDFDevice::internalDrawGlyphRun(const SkGlyphRun& glyphRun, SkPoint offset) {
- const SkGlyphID* glyphs = glyphRun.glyphsIDs().data();
- uint32_t glyphCount = SkToU32(glyphRun.glyphsIDs().size());
+ const SkGlyphID* glyphs = glyphRun.shuntGlyphsIDs().data();
+ uint32_t glyphCount = SkToU32(glyphRun.shuntGlyphsIDs().size());
SkPaint srcPaint{glyphRun.paint()};
srcPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
srcPaint.setTextAlign(SkPaint::kLeft_Align);
diff --git a/src/svg/SkSVGDevice.cpp b/src/svg/SkSVGDevice.cpp
index f85b9a9..ffb4723 100644
--- a/src/svg/SkSVGDevice.cpp
+++ b/src/svg/SkSVGDevice.cpp
@@ -872,7 +872,7 @@
const SkPaint& paint = glyphRun.paint();
auto runSize = glyphRun.runSize();
SkAutoSTArray<64, SkUnichar> unichars(runSize);
- paint.glyphsToUnichars(glyphRun.glyphsIDs().data(), runSize, unichars.get());
+ paint.glyphsToUnichars(glyphRun.shuntGlyphsIDs().data(), runSize, unichars.get());
auto positions = glyphRun.positions();
for (size_t i = 0; i < runSize; ++i) {
this->appendUnichar(unichars[i], positions[i]);
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
index 60450eb..9b97b03 100644
--- a/tests/PDFPrimitivesTest.cpp
+++ b/tests/PDFPrimitivesTest.cpp
@@ -493,8 +493,10 @@
SkPaint paint, const uint32_t* clusters,
size_t utf8TextByteLength, const char* utf8Text) {
return SkGlyphRun(paint, SkRunFont{paint},
+ SkSpan<const uint16_t>{}, // No dense indices for now.
SkSpan<const SkPoint>{pos, len},
SkSpan<const SkGlyphID>{glyphs, len},
+ SkSpan<const SkGlyphID>{},
SkSpan<const char>{utf8Text, utf8TextByteLength},
SkSpan<const uint32_t>{clusters, len});
}