diff --git a/src/core/SkGlyphRun.cpp b/src/core/SkGlyphRun.cpp
index a9ba900..e7bab33 100644
--- a/src/core/SkGlyphRun.cpp
+++ b/src/core/SkGlyphRun.cpp
@@ -35,6 +35,55 @@
 }
 }  // namespace
 
+// -- SkGlyphSet ----------------------------------------------------------------------------------
+uint32_t SkGlyphSet::uniqueSize() {
+    // The size is how big the vector is grown since being passed into reuse.
+    return fUniqueGlyphIDs->size() - fStartOfUniqueIDs;
+}
+
+uint16_t SkGlyphSet::add(SkGlyphID glyphID) {
+    static constexpr SkGlyphID  kUndefGlyph{0};
+
+    if (glyphID >= fUniverseSize) {
+        glyphID = kUndefGlyph;
+    }
+
+    if (glyphID >= fIndices.size()) {
+        fIndices.resize(glyphID + 1);
+    }
+
+    auto index = fIndices[glyphID];
+
+    // Remember we start at the end of what ever was passed in.
+    if (index < this->uniqueSize() && (*fUniqueGlyphIDs)[fStartOfUniqueIDs + index] == glyphID) {
+        return index;
+    }
+
+    uint16_t newIndex = SkTo<uint16_t>(this->uniqueSize());
+    fUniqueGlyphIDs->push_back(glyphID);
+    fIndices[glyphID] = newIndex;
+    return newIndex;
+}
+
+void SkGlyphSet::reuse(uint32_t glyphUniverseSize, std::vector<SkGlyphID>* uniqueGlyphIDs) {
+    SkASSERT(glyphUniverseSize <= (1 << 16));
+    fUniverseSize = glyphUniverseSize;
+    fUniqueGlyphIDs = uniqueGlyphIDs;
+
+    // Capture the vector end to act as the start of a new unique id vector.
+    fStartOfUniqueIDs = uniqueGlyphIDs->size();
+
+    // If we're hanging onto these arrays for a long time, we don't want their size to drift
+    // endlessly upwards. It's unusual to see a typeface with more than 4096 possible glyphs.
+    if (glyphUniverseSize < 4096 && fIndices.size() > 4096) {
+        fIndices.resize(4096);
+        fIndices.shrink_to_fit();
+    }
+
+    // No need to clear fIndices here... SkGlyphSet's set insertion algorithm is designed to work
+    // correctly even when the fIndexes buffer is uninitialized!
+}
+
 // -- SkGlyphRun -----------------------------------------------------------------------------------
 SkGlyphRun::SkGlyphRun(SkPaint&& runPaint,
                        SkSpan<const uint16_t> denseIndices,
@@ -69,146 +118,83 @@
     callback(fTemporaryShuntGlyphIDs.size(), bytes, pos);
 }
 
-// -- SkGlyphIDSet ---------------------------------------------------------------------------------
-// A faster set implementation that does not need any initialization, and reading the set items
-// is order the number of items, and not the size of the universe.
-// This implementation is based on the paper by Briggs and Torczon, "An Efficient Representation
-// for Sparse Sets"
-//
-// This implementation assumes that the unique glyphs added are appended to a vector that may
-// already have unique glyph from a previous computation. This allows the packing of multiple
-// UniqueID sequences in a single vector.
-SkSpan<const SkGlyphID> SkGlyphIDSet::uniquifyGlyphIDs(
-        uint32_t universeSize,
-        SkSpan<const SkGlyphID> glyphIDs,
-        SkGlyphID* uniqueGlyphIDs,
-        uint16_t* denseIndices) {
-    static constexpr SkGlyphID  kUndefGlyph{0};
-
-    if (universeSize > fUniverseToUniqueSize) {
-        fUniverseToUnique.reset(universeSize);
-        fUniverseToUniqueSize = universeSize;
-    }
-
-    // No need to clear fUniverseToUnique here... the set insertion algorithm is designed to work
-    // correctly even when the fUniverseToUnique buffer is uninitialized!
-
-    size_t uniqueSize = 0;
-    size_t denseIndicesCursor = 0;
-    for (auto glyphID : glyphIDs) {
-
-        // If the glyphID is not in range then it is the undefined glyph.
-        if (glyphID >= universeSize) {
-            glyphID = kUndefGlyph;
-        }
-
-        // The index into the unique ID vector.
-        auto uniqueIndex = fUniverseToUnique[glyphID];
-
-        if (uniqueIndex >= uniqueSize || uniqueGlyphIDs[uniqueIndex] != glyphID) {
-            uniqueIndex = SkTo<uint16_t>(uniqueSize);
-            uniqueGlyphIDs[uniqueSize] = glyphID;
-            fUniverseToUnique[glyphID] = uniqueIndex;
-            uniqueSize += 1;
-        }
-
-        denseIndices[denseIndicesCursor++] = uniqueIndex;
-    }
-
-    // If we're hanging onto these arrays for a long time, we don't want their size to drift
-    // endlessly upwards. It's unusual to see a typeface with more than 4096 possible glyphs.
-    if (fUniverseToUniqueSize > 4096) {
-        fUniverseToUnique.reset(4096);
-        fUniverseToUniqueSize = 4096;
-    }
-
-    return SkSpan<const SkGlyphID>(uniqueGlyphIDs, uniqueSize);
-}
-
 // -- SkGlyphRunBuilder ----------------------------------------------------------------------------
 void SkGlyphRunBuilder::prepareDrawText(
         const SkPaint& paint, const void* bytes, size_t byteLength, SkPoint origin) {
-    auto glyphIDs = textToGlyphIDs(paint, bytes, byteLength);
-    this->initialize(glyphIDs.size());
+    this->initialize();
     SkSpan<const char> originalText((const char*)bytes, byteLength);
     if (paint.getTextEncoding() != SkPaint::kUTF8_TextEncoding) {
         originalText = SkSpan<const char>();
     }
-    this->drawText(paint, glyphIDs, origin, originalText, SkSpan<const uint32_t>());
+    this->drawText(paint, bytes, byteLength, origin, originalText, SkSpan<const uint32_t>());
 }
 
 void SkGlyphRunBuilder::prepareDrawPosTextH(const SkPaint& paint, const void* bytes,
                                             size_t byteLength, const SkScalar* xpos,
                                             SkScalar constY) {
-    auto glyphIDs = textToGlyphIDs(paint, bytes, byteLength);
-    this->initialize(glyphIDs.size());
+    this->initialize();
     this->drawPosTextH(
-            paint, glyphIDs, xpos, constY, SkSpan<const char>(), SkSpan<const uint32_t>());
+            paint, bytes, byteLength, xpos, constY, SkSpan<const char>(), SkSpan<const uint32_t>());
 }
 
 void SkGlyphRunBuilder::prepareDrawPosText(const SkPaint& paint, const void* bytes,
                                            size_t byteLength, const SkPoint* pos) {
-    auto glyphIDs = textToGlyphIDs(paint, bytes, byteLength);
-    this->initialize(glyphIDs.size());
-    this->drawPosText(paint, glyphIDs, pos, SkSpan<const char>(), SkSpan<const uint32_t>());
+    this->initialize();
+    this->drawPosText(paint, bytes, byteLength, pos,
+            SkSpan<const char>(), SkSpan<const uint32_t>());
 }
 
 SkGlyphRun* SkGlyphRunBuilder::useGlyphRun() {
     return &fScratchGlyphRun;
 }
 
-void SkGlyphRunBuilder::initialize(size_t totalRunSize) {
+void SkGlyphRunBuilder::initialize() {
     fUniqueID = 0;
-
-    // Using resize is temporary until simpler buffers are in place.
-    fDenseIndex.resize(totalRunSize);
-    fPositions.resize(totalRunSize);
-    fUniqueGlyphIDs.resize(totalRunSize);
+    fDenseIndex.clear();
+    fPositions.clear();
+    fUniqueGlyphIDs.clear();
 
     // Be sure to clean up the last run before we reuse it.
     fScratchGlyphRun.~SkGlyphRun();
 }
 
-SkSpan<const SkGlyphID> SkGlyphRunBuilder::textToGlyphIDs(
+void SkGlyphRunBuilder::addDenseAndUnique(
         const SkPaint& paint, const void* bytes, size_t byteLength) {
+
+    size_t runSize = 0;
+    SkGlyphID* glyphIDs = nullptr;
     auto encoding = paint.getTextEncoding();
+    auto typeface = SkPaintPriv::GetTypefaceOrDefault(paint);
     if (encoding != SkPaint::kGlyphID_TextEncoding) {
         auto tfEncoding = convert_encoding(encoding);
         int utfSize = SkUTFN_CountUnichars(tfEncoding, bytes, byteLength);
         if (utfSize > 0) {
-            size_t runSize = SkTo<size_t>(utfSize);
+            runSize = SkTo<size_t>(utfSize);
             fScratchGlyphIDs.resize(runSize);
-            auto typeface = SkPaintPriv::GetTypefaceOrDefault(paint);
             typeface->charsToGlyphs(bytes, tfEncoding, fScratchGlyphIDs.data(), runSize);
-            return SkSpan<const SkGlyphID>{fScratchGlyphIDs};
-        } else {
-            return SkSpan<const SkGlyphID>();
+            glyphIDs = fScratchGlyphIDs.data();
         }
     } else {
-        return SkSpan<const SkGlyphID>((const SkGlyphID*)bytes, byteLength / 2);
-    }
-}
-
-SkSpan<const SkGlyphID> SkGlyphRunBuilder::addDenseAndUnique(
-        const SkPaint& paint,
-        SkSpan<const SkGlyphID> glyphIDs) {
-    SkSpan<const SkGlyphID> uniquifiedGlyphIDs;
-    if (!glyphIDs.empty()) {
-        auto typeface = SkPaintPriv::GetTypefaceOrDefault(paint);
-        auto glyphUniverseSize = typeface->countGlyphs();
-        uniquifiedGlyphIDs = fGlyphIDSet.uniquifyGlyphIDs(
-                glyphUniverseSize, glyphIDs, fUniqueGlyphIDs.data(), fDenseIndex.data());
+        runSize = byteLength / 2;
+        glyphIDs = (SkGlyphID*)bytes;
     }
 
-    return uniquifiedGlyphIDs;
+    // TODO: Remove when glyphIds are passed back.
+    fGlyphIDs = glyphIDs;
+
+    SkASSERT(glyphIDs != nullptr);
+
+    if (runSize > 0) {
+        fGlyphSet.reuse(typeface->countGlyphs(), &fUniqueGlyphIDs);
+        for (size_t i = 0; i < runSize; i++) {
+            fDenseIndex.push_back(fGlyphSet.add(glyphIDs[i]));
+        }
+    }
 }
 
 void SkGlyphRunBuilder::makeGlyphRun(
         const SkPaint& runPaint,
-        SkSpan<const SkGlyphID> glyphIDs,
-        SkSpan<const SkPoint> positions,
-        SkSpan<const char> text,
-        SkSpan<const uint32_t> clusters) {
+        SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
 
     // Ignore empty runs.
     if (!fDenseIndex.empty()) {
@@ -219,8 +205,8 @@
         new ((void*)&fScratchGlyphRun) SkGlyphRun{
                 std::move(glyphRunPaint),
                 SkSpan<const uint16_t>{fDenseIndex},
-                positions,
-                glyphIDs,
+                SkSpan<const SkPoint>{fPositions},
+                SkSpan<const SkGlyphID>{fGlyphIDs, SkTo<ptrdiff_t>(fDenseIndex.size())},
                 SkSpan<const SkGlyphID>{fUniqueGlyphIDs},
                 text,
                 clusters
@@ -229,21 +215,21 @@
 }
 
 void SkGlyphRunBuilder::drawText(
-        const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs, SkPoint origin,
+        const SkPaint& paint, const void* bytes, size_t byteLength, SkPoint origin,
         SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
 
-    auto unqiueGlyphIDs = this->addDenseAndUnique(paint, glyphIDs);
+    this->addDenseAndUnique(paint, bytes, byteLength);
 
     fScratchAdvances.resize(fUniqueGlyphIDs.size());
     {
         auto cache = SkStrikeCache::FindOrCreateStrikeExclusive(paint);
-        cache->getAdvances(unqiueGlyphIDs, fScratchAdvances.data());
+        cache->getAdvances(SkSpan<const SkGlyphID>{fUniqueGlyphIDs}, fScratchAdvances.data());
     }
 
     SkPoint endOfLastGlyph = origin;
 
     for (size_t i = 0; i < fDenseIndex.size(); i++) {
-        fPositions[i] = endOfLastGlyph;
+        fPositions.push_back(endOfLastGlyph);
         endOfLastGlyph += fScratchAdvances[fDenseIndex[i]];
     }
 
@@ -257,39 +243,33 @@
         }
     }
 
-    this->makeGlyphRun(paint, glyphIDs, SkSpan<const SkPoint>{fPositions}, text, clusters);
+    this->makeGlyphRun(paint, text, clusters);
 }
 
-void SkGlyphRunBuilder::drawPosTextH(const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs,
-                                     const SkScalar* xpos, SkScalar constY,
+void SkGlyphRunBuilder::drawPosTextH(const SkPaint& paint, const void* bytes,
+                                     size_t byteLength, const SkScalar* xpos,
+                                     SkScalar constY,
                                      SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
 
-    // The dense indices are not used by the rest of the stack yet.
-    #ifdef SK_DEBUG
-        this->addDenseAndUnique(paint, glyphIDs);
-    #endif
+    this->addDenseAndUnique(paint, bytes, byteLength);
 
     for (size_t i = 0; i < fDenseIndex.size(); i++) {
-        fPositions[i] = SkPoint::Make(xpos[i], constY);
+        fPositions.push_back(SkPoint::Make(xpos[i], constY));
     }
 
-    this->makeGlyphRun(paint, glyphIDs, SkSpan<const SkPoint>{fPositions}, text, clusters);
+    this->makeGlyphRun(paint, text, clusters);
 }
 
-void SkGlyphRunBuilder::drawPosText(const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs,
-                                    const SkPoint* pos,
+void SkGlyphRunBuilder::drawPosText(const SkPaint& paint, const void* bytes,
+                                    size_t byteLength, const SkPoint* pos,
                                     SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
-
-    // The dense indices are not used by the rest of the stack yet.
-    #ifdef SK_DEBUG
-        this->addDenseAndUnique(paint, glyphIDs);
-    #endif
+    this->addDenseAndUnique(paint, bytes, byteLength);
 
     for (size_t i = 0; i < fDenseIndex.size(); i++) {
-        fPositions[i] = pos[i];
+        fPositions.push_back(pos[i]);
     }
 
-    this->makeGlyphRun(paint, glyphIDs, SkSpan<const SkPoint>{fPositions}, text, clusters);
+    this->makeGlyphRun(paint, text, clusters);
 }
 
 
diff --git a/src/core/SkGlyphRun.h b/src/core/SkGlyphRun.h
index 7c3a748..7788376 100644
--- a/src/core/SkGlyphRun.h
+++ b/src/core/SkGlyphRun.h
@@ -83,14 +83,26 @@
     const SkPaint fRunPaint;
 };
 
-class SkGlyphIDSet {
+// A faster set implementation that does not need any initialization, and reading the set items
+// is order the number of items, and not the size of the universe.
+// This implementation is based on the paper by Briggs and Torczon, "An Efficient Representation
+// for Sparse Sets"
+//
+// This implementation assumes that the unique glyphs added are appended to a vector that may
+// already have unique glyph from a previous computation. This allows the packing of multiple
+// UniqueID sequences in a single vector.
+class SkGlyphSet {
 public:
-    SkSpan<const SkGlyphID> uniquifyGlyphIDs(
-            uint32_t universeSize, SkSpan<const SkGlyphID> glyphIDs,
-            SkGlyphID* uniqueGlyphIDs, uint16_t* denseindices);
+    SkGlyphSet() = default;
+    uint16_t add(SkGlyphID glyphID);
+    void reuse(uint32_t glyphUniverseSize, std::vector<SkGlyphID>* uniqueGlyphIDs);
+
 private:
-    size_t fUniverseToUniqueSize{0};
-    SkAutoTMalloc<uint16_t> fUniverseToUnique;
+    uint32_t uniqueSize();
+    uint32_t                    fUniverseSize{0};
+    size_t                      fStartOfUniqueIDs{0};
+    std::vector<uint16_t>       fIndices;
+    std::vector<SkGlyphID>*     fUniqueGlyphIDs{nullptr};
 };
 
 class SkGlyphRunBuilder {
@@ -103,35 +115,25 @@
             const SkScalar xpos[], SkScalar constY);
     void prepareDrawPosText(
             const SkPaint& paint, const void* bytes, size_t byteLength, const SkPoint pos[]);
+    void prepareTextBlob(const SkPaint& paint, const SkTextBlob& blob, SkPoint origin);
 
     SkGlyphRun* useGlyphRun();
 
 private:
-    void initialize(size_t totalRunSize);
-    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);
-
+    void initialize();
+    void addDenseAndUnique(const SkPaint& paint, const void* bytes, size_t byteLength);
     void makeGlyphRun(
-            const SkPaint& runPaint,
-            SkSpan<const SkGlyphID> glyphIDs,
-            SkSpan<const SkPoint> positions,
-            SkSpan<const char> text,
-            SkSpan<const uint32_t> clusters);
+            const SkPaint& runPaint, SkSpan<const char> text, SkSpan<const uint32_t> clusters);
 
     void drawText(
-            const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs, SkPoint origin,
+            const SkPaint& paint, const void* bytes, size_t byteLength, SkPoint origin,
             SkSpan<const char> text, SkSpan<const uint32_t> clusters);
     void drawPosTextH(
-            const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs,
+            const SkPaint& paint, const void* bytes, size_t byteLength,
             const SkScalar* xpos, SkScalar constY,
             SkSpan<const char> text, SkSpan<const uint32_t> clusters);
     void drawPosText(
-            const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs, const SkPoint* pos,
+            const SkPaint& paint, const void* bytes, size_t byteLength, const SkPoint* pos,
             SkSpan<const char> text, SkSpan<const uint32_t> clusters);
 
     uint64_t fUniqueID{0};
@@ -139,6 +141,7 @@
     std::vector<uint16_t> fDenseIndex;
     std::vector<SkPoint> fPositions;
     std::vector<SkGlyphID> fUniqueGlyphIDs;
+    SkGlyphID* fGlyphIDs{nullptr};
 
     // 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.
@@ -152,7 +155,7 @@
     SkGlyphRun fScratchGlyphRun;
 
     // Used for collecting the set of unique glyphs.
-    SkGlyphIDSet fGlyphIDSet;
+    SkGlyphSet fGlyphSet;
 };
 
 #endif  // SkGlyphRunInfo_DEFINED
diff --git a/tests/GlyphRunTest.cpp b/tests/GlyphRunTest.cpp
index 0e0c441..46b4715 100644
--- a/tests/GlyphRunTest.cpp
+++ b/tests/GlyphRunTest.cpp
@@ -11,32 +11,25 @@
 
 #include "Test.h"
 
-DEF_TEST(GlyphRunGlyphIDSetBasic, reporter) {
-    SkGlyphID glyphs[] = {100, 3, 240, 3, 234};
-    auto glyphIDs = SkSpan<const SkGlyphID>(glyphs, SK_ARRAY_COUNT(glyphs));
-    int universeSize = 1000;
-    SkGlyphID uniqueGlyphs[SK_ARRAY_COUNT(glyphs)];
-    uint16_t denseIndices[SK_ARRAY_COUNT(glyphs)];
+DEF_TEST(GlyphSetBasic, reporter) {
+    SkGlyphSet set;
 
-    SkGlyphIDSet gs;
-    auto uniqueGlyphIDs = gs.uniquifyGlyphIDs(universeSize, glyphIDs, uniqueGlyphs, denseIndices);
+    std::vector<SkGlyphID> unique;
 
-    std::vector<SkGlyphID> test{uniqueGlyphIDs.begin(), uniqueGlyphIDs.end()};
-    std::sort(test.begin(), test.end());
-    auto newEnd = std::unique(test.begin(), test.end());
-    REPORTER_ASSERT(reporter, uniqueGlyphIDs.size() == newEnd - test.begin());
-    REPORTER_ASSERT(reporter, uniqueGlyphIDs.size() == 4);
-    {
-        uint16_t answer[] = {0, 1, 2, 1, 3};
-        REPORTER_ASSERT(reporter,
-                        std::equal(answer, std::end(answer), denseIndices));
-    }
+    set.reuse(10, &unique);
+    REPORTER_ASSERT(reporter, set.add(7) == 0);
+    REPORTER_ASSERT(reporter, set.add(3) == 1);
+    set.reuse(10, &unique);
+    REPORTER_ASSERT(reporter, set.add(5) == 0);
+    REPORTER_ASSERT(reporter, set.add(8) == 1);
+    REPORTER_ASSERT(reporter, set.add(3) == 2);
 
-    {
-        SkGlyphID answer[] = {100, 3, 240, 234};
-        REPORTER_ASSERT(reporter,
-                        std::equal(answer, std::end(answer), uniqueGlyphs));
-    }
+    REPORTER_ASSERT(reporter, unique.size() == 5);
+    REPORTER_ASSERT(reporter, unique[0] == 7);
+    REPORTER_ASSERT(reporter, unique[1] == 3);
+    REPORTER_ASSERT(reporter, unique[2] == 5);
+    REPORTER_ASSERT(reporter, unique[3] == 8);
+    REPORTER_ASSERT(reporter, unique[4] == 3);
 }
 
 DEF_TEST(GlyphRunBasic, reporter) {