diff --git a/bench/GlyphQuadFillBench.cpp b/bench/GlyphQuadFillBench.cpp
index 70190d1..243b4cb 100644
--- a/bench/GlyphQuadFillBench.cpp
+++ b/bench/GlyphQuadFillBench.cpp
@@ -39,7 +39,7 @@
         size_t len = strlen(gText);
         SkGlyphRunBuilder builder;
         SkPaint paint;
-        auto glyphRunList = builder.textToGlyphRunList(font, gText, len, {100, 100});
+        auto glyphRunList = builder.textToGlyphRunList(font, paint, gText, len, {100, 100});
         SkASSERT(!glyphRunList.empty());
         SkSurfaceProps props;
         if (canvas) { canvas->getProps(&props); }
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index e06094c..a8da995 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -2278,12 +2278,13 @@
 
 void SkCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                               const SkPaint& paint) {
-    const SkRect bounds = blob->bounds().makeOffset(x, y);
-    if (this->internalQuickReject(bounds, paint)) {
+    const SkRect blobBounds = blob->bounds().makeOffset(x, y);
+    if (this->internalQuickReject(blobBounds, paint)) {
         return;
     }
 
     auto glyphRunList = fScratchGlyphRunBuilder->blobToGlyphRunList(*blob, {x, y});
+    SkRect bounds = glyphRunList.sourceBounds();
     AutoLayerForImageFilter layer(this, paint, &bounds);
     this->topDevice()->drawGlyphRunList(glyphRunList, layer.paint());
 }
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index ef67573..c2fc270 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -448,7 +448,7 @@
                                                     const SkPaint& paint) {
     for (const SkGlyphRun& run : glyphRunList) {
         if (run.scaledRotations().empty()) {
-            this->drawGlyphRunList(SkGlyphRunList{run}, paint);
+            this->drawGlyphRunList(SkGlyphRunList{run, run.sourceBounds(paint)}, paint);
         } else {
             SkPoint origin = glyphRunList.origin();
             SkPoint sharedPos{0, 0};    // we're at the origin
@@ -477,7 +477,8 @@
                 SkPaint invertingPaint{paint};
                 invertingPaint.setShader(make_post_inverse_lm(paint.getShader(), glyphToLocal));
                 this->setLocalToDevice(originalLocalToDevice * SkM44(glyphToLocal));
-                this->drawGlyphRunList(SkGlyphRunList{glyphRun}, invertingPaint);
+                this->drawGlyphRunList(
+                        SkGlyphRunList{glyphRun, glyphRun.sourceBounds(paint)}, invertingPaint);
             }
             this->setLocalToDevice(originalLocalToDevice);
         }
diff --git a/src/core/SkGlyphRun.cpp b/src/core/SkGlyphRun.cpp
index b95a0a7..a50dfdb 100644
--- a/src/core/SkGlyphRun.cpp
+++ b/src/core/SkGlyphRun.cpp
@@ -39,19 +39,87 @@
     , fClusters{that.fClusters}
     , fFont{font} {}
 
+SkRect SkGlyphRun::sourceBounds(const SkPaint& paint) const {
+    SkASSERT(this->runSize() > 0);
+    const SkRect fontBounds = SkFontPriv::GetFontBounds(fFont);
+
+    if (fontBounds.isEmpty()) {
+        // Empty font bounds are likely a font bug.  TightBounds has a better chance of
+        // producing useful results in this case.
+        SkStrikeSpec strikeSpec = SkStrikeSpec::MakeCanonicalized(fFont, &paint);
+        SkBulkGlyphMetrics metrics{strikeSpec};
+        SkSpan<const SkGlyph*> glyphs = metrics.glyphs(this->glyphsIDs());
+        if (fScaledRotations.empty()) {
+            // No RSXForm data - glyphs x/y aligned.
+            auto scaleAndTranslateRect =
+                [scale = strikeSpec.strikeToSourceRatio()](const SkRect& in, const SkPoint& pos) {
+                    return SkRect::MakeLTRB(in.left()   * scale + pos.x(),
+                                            in.top()    * scale + pos.y(),
+                                            in.right()  * scale + pos.x(),
+                                            in.bottom() * scale + pos.y());
+                };
+
+            SkRect bounds = SkRect::MakeEmpty();
+            for (auto [pos, glyph] : SkMakeZip(this->positions(), glyphs)) {
+                if (SkRect r = glyph->rect(); !r.isEmpty()) {
+                    bounds.join(scaleAndTranslateRect(r, pos));
+                }
+            }
+            return bounds;
+        } else {
+            // RSXForm - glyphs can be any scale or rotation.
+            SkScalar scale = strikeSpec.strikeToSourceRatio();
+            SkRect bounds = SkRect::MakeEmpty();
+            for (auto [pos, scaleRotate, glyph] :
+                    SkMakeZip(this->positions(), fScaledRotations, glyphs)) {
+                if (!glyph->rect().isEmpty()) {
+                    SkMatrix xform = SkMatrix().setRSXform(
+                            SkRSXform{pos.x(), pos.y(), scaleRotate.x(), scaleRotate.y()});
+                    xform.preScale(scale, scale);
+                    bounds.join(xform.mapRect(glyph->rect()));
+                }
+            }
+            return bounds;
+        }
+    }
+
+    // Use conservative bounds. All glyph have a box of fontBounds size.
+    if (fScaledRotations.empty()) {
+        SkRect bounds;
+        bounds.setBounds(this->positions().data(), this->positions().count());
+        bounds.fLeft   += fontBounds.left();
+        bounds.fTop    += fontBounds.top();
+        bounds.fRight  += fontBounds.right();
+        bounds.fBottom += fontBounds.bottom();
+        return bounds;
+    } else {
+        // RSXForm case glyphs can be any scale or rotation.
+        SkRect bounds;
+        bounds.setEmpty();
+        for (auto [pos, scaleRotate] : SkMakeZip(this->positions(), fScaledRotations)) {
+            const SkRSXform xform{pos.x(), pos.y(), scaleRotate.x(), scaleRotate.y()};
+            bounds.join(SkMatrix().setRSXform(xform).mapRect(fontBounds));
+        }
+        return bounds;
+    }
+}
+
 // -- SkGlyphRunList -------------------------------------------------------------------------------
 SkGlyphRunList::SkGlyphRunList() = default;
 SkGlyphRunList::SkGlyphRunList(
         const SkTextBlob* blob,
+        SkRect bounds,
         SkPoint origin,
         SkSpan<const SkGlyphRun> glyphRunList)
         : fGlyphRuns{glyphRunList}
         , fOriginalTextBlob{blob}
+        , fSourceBounds{bounds}
         , fOrigin{origin} { }
 
-SkGlyphRunList::SkGlyphRunList(const SkGlyphRun& glyphRun)
+SkGlyphRunList::SkGlyphRunList(const SkGlyphRun& glyphRun, const SkRect& bounds)
         : fGlyphRuns{SkSpan<const SkGlyphRun>{&glyphRun, 1}}
         , fOriginalTextBlob{nullptr}
+        , fSourceBounds{bounds}
         , fOrigin{SkPoint::Make(0, 0)} {}
 
 uint64_t SkGlyphRunList::uniqueID() const {
@@ -90,9 +158,11 @@
 }
 
 const SkGlyphRunList& SkGlyphRunBuilder::textToGlyphRunList(
-        const SkFont& font, const void* bytes, size_t byteLength, SkPoint origin,
+        const SkFont& font, const SkPaint& paint,
+        const void* bytes, size_t byteLength, SkPoint origin,
         SkTextEncoding encoding) {
     auto glyphIDs = textToGlyphIDs(font, bytes, byteLength, encoding);
+    SkRect bounds = SkRect::MakeEmpty();
     if (!glyphIDs.empty()) {
         this->initialize(glyphIDs.size());
         SkSpan<const SkPoint> positions = draw_text_positions(font, glyphIDs, {0, 0}, fPositions);
@@ -102,9 +172,10 @@
                            SkSpan<const char>{},
                            SkSpan<const uint32_t>{},
                            SkSpan<const SkVector>{});
+        bounds = fGlyphRunListStorage.front().sourceBounds(paint);
     }
 
-    return this->makeGlyphRunList(nullptr, origin);
+    return this->makeGlyphRunList(nullptr, bounds.makeOffset(origin), origin);
 }
 
 const SkGlyphRunList& SkGlyphRunBuilder::blobToGlyphRunList(
@@ -163,7 +234,7 @@
                 scaledRotations);
     }
 
-    return this->makeGlyphRunList(&blob, origin);
+    return this->makeGlyphRunList(&blob, blob.bounds().makeOffset(origin), origin);
 }
 
 void SkGlyphRunBuilder::initialize(int totalRunSize) {
@@ -237,8 +308,8 @@
     }
 }
 
-const SkGlyphRunList& SkGlyphRunBuilder::makeGlyphRunList(const SkTextBlob* blob, SkPoint origin) {
-
+const SkGlyphRunList& SkGlyphRunBuilder::makeGlyphRunList(
+        const SkTextBlob* blob, const SkRect& bounds, SkPoint origin) {
     fGlyphRunList.~SkGlyphRunList();
-    return *new (&fGlyphRunList) SkGlyphRunList{blob, origin, SkSpan(fGlyphRunListStorage)};
+    return *new (&fGlyphRunList) SkGlyphRunList{blob, bounds, origin, SkSpan(fGlyphRunListStorage)};
 }
diff --git a/src/core/SkGlyphRun.h b/src/core/SkGlyphRun.h
index 45a3f66..c972031 100644
--- a/src/core/SkGlyphRun.h
+++ b/src/core/SkGlyphRun.h
@@ -44,6 +44,7 @@
     SkSpan<const uint32_t> clusters() const { return fClusters; }
     SkSpan<const char> text() const { return fText; }
     SkSpan<const SkVector> scaledRotations() const { return fScaledRotations; }
+    SkRect sourceBounds(const SkPaint& paint) const;
 
 private:
     // GlyphIDs and positions.
@@ -66,10 +67,11 @@
     // Blob maybe null.
     SkGlyphRunList(
             const SkTextBlob* blob,
+            SkRect bounds,
             SkPoint origin,
             SkSpan<const SkGlyphRun> glyphRunList);
 
-    SkGlyphRunList(const SkGlyphRun& glyphRun);
+    SkGlyphRunList(const SkGlyphRun& glyphRun, const SkRect& bounds);
 
     uint64_t uniqueID() const;
     bool anyRunsLCD() const;
@@ -93,6 +95,7 @@
     }
 
     SkPoint origin() const { return fOrigin; }
+    SkRect sourceBounds() const { return fSourceBounds; }
     const SkTextBlob* blob() const { return fOriginalTextBlob; }
 
     auto begin() -> decltype(fGlyphRuns.begin())               { return fGlyphRuns.begin();  }
@@ -106,13 +109,15 @@
 private:
     // The text blob is needed to hookup the call back that the SkTextBlob destructor calls. It
     // should be used for nothing else
-    const SkTextBlob*  fOriginalTextBlob{nullptr};
-    SkPoint fOrigin = {0, 0};
+    const SkTextBlob* fOriginalTextBlob{nullptr};
+    const SkRect fSourceBounds{SkRect::MakeEmpty()};
+    const SkPoint fOrigin = {0, 0};
 };
 
 class SkGlyphRunBuilder {
 public:
     const SkGlyphRunList& textToGlyphRunList(const SkFont& font,
+                                             const SkPaint& paint,
                                              const void* bytes,
                                              size_t byteLength,
                                              SkPoint origin,
@@ -135,10 +140,8 @@
             SkSpan<const uint32_t> clusters,
             SkSpan<const SkVector> scaledRotations);
 
-    const SkGlyphRunList& makeGlyphRunList(const SkTextBlob* blob, SkPoint origin);
-
-    SkPoint* simplifyTextBlobIgnoringRSXForm(const SkTextBlobRunIterator& it,
-                                             SkPoint* positionsCursor);
+    const SkGlyphRunList& makeGlyphRunList(
+            const SkTextBlob* blob, const SkRect& bounds, SkPoint origin);
 
     int fMaxTotalRunSize{0};
     SkAutoTMalloc<SkPoint> fPositions;
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index dcaf5e3..2553c95 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -497,7 +497,7 @@
     drawMatrix.preTranslate(x, y);
     auto drawOrigin = SkPoint::Make(x, y);
     SkGlyphRunBuilder builder;
-    auto glyphRunList = builder.textToGlyphRunList(font, text, textLen, drawOrigin);
+    auto glyphRunList = builder.textToGlyphRunList(font, skPaint, text, textLen, drawOrigin);
     if (glyphRunList.empty()) {
         return nullptr;
     }