diff --git a/gm/textblobrandomfont.cpp b/gm/textblobrandomfont.cpp
new file mode 100644
index 0000000..a95966e
--- /dev/null
+++ b/gm/textblobrandomfont.cpp
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "gm.h"
+
+#include "Resources.h"
+#include "SkCanvas.h"
+#include "SkGradientShader.h"
+#include "SkStream.h"
+#include "SkSurface.h"
+#include "SkTextBlob.h"
+#include "SkTypeface.h"
+#include "../src/fonts/SkRandomScalerContext.h"
+
+#if SK_SUPPORT_GPU
+
+#include "GrContext.h"
+
+namespace skiagm {
+class TextBlobRandomFont : public GM {
+public:
+    // This gm tests that textblobs can be translated and scaled with a font that returns random
+    // but deterministic masks
+    TextBlobRandomFont() { }
+
+protected:
+    void onOnceBeforeDraw() override {
+        SkTextBlobBuilder builder;
+
+        const char* text = "The quick brown fox jumps over the lazy dog.";
+
+        // make textbloben
+        SkPaint paint;
+        paint.setTextSize(32);
+        paint.setLCDRenderText(true);
+
+        // Setup our random scaler context
+        SkAutoTUnref<SkTypeface> orig(sk_tool_utils::create_portable_typeface("sans-serif",
+                                                                              SkTypeface::kBold));
+        if (NULL == orig) {
+            orig.reset(SkTypeface::RefDefault());
+        }
+        SkAutoTUnref<SkTypeface> random(SkNEW_ARGS(SkRandomTypeface, (orig, paint, false)));
+        paint.setTypeface(random);
+
+        SkRect bounds;
+        paint.measureText(text, strlen(text), &bounds);
+        sk_tool_utils::add_to_text_blob(&builder, text, paint, 0, 0);
+
+        // A8
+        const char* bigtext1 = "The quick brown fox";
+        const char* bigtext2 = "jumps over the lazy dog.";
+        paint.setTextSize(160);
+        paint.setSubpixelText(false);
+        paint.setLCDRenderText(false);
+        paint.measureText(bigtext1, strlen(bigtext1), &bounds);
+        SkScalar offset = bounds.height();
+        sk_tool_utils::add_to_text_blob(&builder, bigtext1, paint, 0, offset);
+
+        paint.measureText(bigtext2, strlen(bigtext2), &bounds);
+        offset += bounds.height();
+        sk_tool_utils::add_to_text_blob(&builder, bigtext2, paint, 0, offset);
+
+        // build
+        fBlob.reset(builder.build());
+    }
+
+    SkString onShortName() override {
+        return SkString("textblobrandomfont");
+    }
+
+    SkISize onISize() override {
+        return SkISize::Make(kWidth, kHeight);
+    }
+
+    void onDraw(SkCanvas* canvas) override {
+        // This GM exists to test a specific feature of the GPU backend.
+        if (NULL == canvas->getGrContext()) {
+            this->drawGpuOnlyMessage(canvas);
+            return;
+        }
+
+        canvas->drawColor(sk_tool_utils::color_to_565(SK_ColorWHITE));
+
+        SkImageInfo info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
+        SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+        SkAutoTUnref<SkSurface> surface(canvas->newSurface(info, &props));
+        if (surface) {
+            SkPaint paint;
+            paint.setAntiAlias(true);
+
+            SkCanvas* c = surface->getCanvas();
+
+            int stride = SkScalarCeilToInt(fBlob->bounds().height());
+            int yOffset = stride / 8;
+            for (int i = 0; i < 1; i++) {
+                // fiddle the canvas to force regen of textblobs
+                canvas->rotate(i % 2 ? 0.0f : -0.05f);
+                canvas->drawTextBlob(fBlob, 10.0f, SkIntToScalar(yOffset), paint);
+                yOffset += stride;
+
+                // This will draw as black boxes
+                c->drawTextBlob(fBlob, 10, SkIntToScalar(yOffset), paint);
+                surface->draw(canvas, 0, 0, nullptr);
+
+                // free gpu resources and verify
+                yOffset += stride;
+                canvas->getGrContext()->freeGpuResources();
+                canvas->drawTextBlob(fBlob, 10, SkIntToScalar(yOffset), paint);
+
+                yOffset += stride;
+            }
+
+        } else {
+            const char* text = "This test requires a surface";
+            size_t len = strlen(text);
+            SkPaint paint;
+            canvas->drawText(text, len, 10, 100, paint);
+        }
+    }
+
+private:
+    SkAutoTUnref<const SkTextBlob> fBlob;
+
+    static const int kWidth = 2000;
+    static const int kHeight = 1600;
+
+    typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+DEF_GM( return SkNEW(TextBlobRandomFont); )
+}
+#endif
diff --git a/gyp/utils.gypi b/gyp/utils.gypi
index f382e10..50a2a1a 100644
--- a/gyp/utils.gypi
+++ b/gyp/utils.gypi
@@ -133,6 +133,8 @@
         #testing
         '<(skia_src_path)/fonts/SkGScalerContext.cpp',
         '<(skia_src_path)/fonts/SkGScalerContext.h',
+        '<(skia_src_path)/fonts/SkRandomScalerContext.cpp',
+        '<(skia_src_path)/fonts/SkRandomScalerContext.cpp',
         '<(skia_src_path)/fonts/SkTestScalerContext.cpp',
         '<(skia_src_path)/fonts/SkTestScalerContext.h',
     ],
diff --git a/include/core/SkTypeface.h b/include/core/SkTypeface.h
index 7d8b892..873c882 100644
--- a/include/core/SkTypeface.h
+++ b/include/core/SkTypeface.h
@@ -367,6 +367,7 @@
     friend class SkPDFCIDFont;
     friend class GrPathRendering;
     friend class GrGLPathRendering;
+    friend class SkRandomTypeface; // For debugging
 
     /** Retrieve detailed typeface metrics.  Used by the PDF backend.
      @param perGlyphInfo Indicate what glyph specific information (advances,
diff --git a/src/core/SkScalerContext.h b/src/core/SkScalerContext.h
index 02b3a76..fe5235a 100644
--- a/src/core/SkScalerContext.h
+++ b/src/core/SkScalerContext.h
@@ -299,6 +299,8 @@
 
     void forceGenerateImageFromPath() { fGenerateImageFromPath = true; }
 
+    void forceOffGenerateImageFromPath() { fGenerateImageFromPath = false; }
+
 private:
     // never null
     SkAutoTUnref<SkTypeface> fTypeface;
@@ -328,6 +330,8 @@
     // When there is a filter, previous steps must create a linear mask
     // and the pre-blend applied as a final step.
     const SkMaskGamma::PreBlend fPreBlendForFilter;
+
+    friend class SkRandomScalerContext; // For debugging
 };
 
 #define kRec_SkDescriptorTag            SkSetFourByteTag('s', 'r', 'e', 'c')
diff --git a/src/fonts/SkRandomScalerContext.cpp b/src/fonts/SkRandomScalerContext.cpp
new file mode 100644
index 0000000..799e51d
--- /dev/null
+++ b/src/fonts/SkRandomScalerContext.cpp
@@ -0,0 +1,258 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkRandomScalerContext.h"
+#include "SkGlyph.h"
+#include "SkPath.h"
+#include "SkCanvas.h"
+#include "SkRasterizer.h"
+
+class SkRandomScalerContext : public SkScalerContext {
+public:
+    SkRandomScalerContext(SkRandomTypeface*, const SkDescriptor*, bool fFakeIt);
+    virtual ~SkRandomScalerContext();
+
+protected:
+    unsigned generateGlyphCount() override;
+    uint16_t generateCharToGlyph(SkUnichar) override;
+    void generateAdvance(SkGlyph*) override;
+    void generateMetrics(SkGlyph*) override;
+    void generateImage(const SkGlyph&) override;
+    void generatePath(const SkGlyph&, SkPath*) override;
+    void generateFontMetrics(SkPaint::FontMetrics*) override;
+
+private:
+    SkRandomTypeface*     fFace;
+    SkScalerContext* fProxy;
+    bool fFakeIt;
+};
+
+#define STD_SIZE    1
+
+#include "SkDescriptor.h"
+
+SkRandomScalerContext::SkRandomScalerContext(SkRandomTypeface* face, const SkDescriptor* desc,
+                                             bool fakeIt)
+        : SkScalerContext(face, desc)
+        , fFace(face)
+        , fFakeIt(fakeIt) {
+    fProxy = face->proxy()->createScalerContext(desc);
+}
+
+SkRandomScalerContext::~SkRandomScalerContext() {
+    SkDELETE(fProxy);
+}
+
+unsigned SkRandomScalerContext::generateGlyphCount() {
+    return fProxy->getGlyphCount();
+}
+
+uint16_t SkRandomScalerContext::generateCharToGlyph(SkUnichar uni) {
+    return fProxy->charToGlyphID(uni);
+}
+
+void SkRandomScalerContext::generateAdvance(SkGlyph* glyph) {
+    fProxy->getAdvance(glyph);
+}
+
+void SkRandomScalerContext::generateMetrics(SkGlyph* glyph) {
+    // Here we will change the mask format of the glyph
+    // NOTE this is being overridden by the base class
+    SkMask::Format format;
+    switch (glyph->getGlyphID() % 4) {
+        case 0:
+            format = SkMask::kLCD16_Format;
+            break;
+        case 1:
+            format = SkMask::kA8_Format;
+            break;
+        case 2:
+            format = SkMask::kARGB32_Format;
+            break;
+        case 3:
+            format = SkMask::kBW_Format;
+            break;
+    }
+
+    fProxy->getMetrics(glyph);
+
+    glyph->fMaskFormat = format;
+    if (fFakeIt) {
+        return;
+    }
+    if (SkMask::kARGB32_Format == format) {
+        SkPath path;
+        fProxy->getPath(*glyph, &path);
+
+        SkRect storage;
+        const SkPaint& paint = fFace->paint();
+        const SkRect& newBounds = paint.doComputeFastBounds(path.getBounds(),
+                                                            &storage,
+                                                            SkPaint::kFill_Style);
+        SkIRect ibounds;
+        newBounds.roundOut(&ibounds);
+        glyph->fLeft = ibounds.fLeft;
+        glyph->fTop = ibounds.fTop;
+        glyph->fWidth = ibounds.width();
+        glyph->fHeight = ibounds.height();
+    } else {
+        SkPath      devPath, fillPath;
+        SkMatrix    fillToDevMatrix;
+
+        this->internalGetPath(*glyph, &fillPath, &devPath, &fillToDevMatrix);
+
+        // just use devPath
+        const SkIRect ir = devPath.getBounds().roundOut();
+
+        if (ir.isEmpty() || !ir.is16Bit()) {
+            glyph->fLeft    = 0;
+            glyph->fTop     = 0;
+            glyph->fWidth   = 0;
+            glyph->fHeight  = 0;
+            return;
+        }
+        glyph->fLeft    = ir.fLeft;
+        glyph->fTop     = ir.fTop;
+        glyph->fWidth   = SkToU16(ir.width());
+        glyph->fHeight  = SkToU16(ir.height());
+
+        if (glyph->fWidth > 0) {
+            switch (glyph->fMaskFormat) {
+            case SkMask::kLCD16_Format:
+                glyph->fWidth += 2;
+                glyph->fLeft -= 1;
+                break;
+            default:
+                break;
+            }
+        }
+    }
+}
+
+void SkRandomScalerContext::generateImage(const SkGlyph& glyph) {
+    SkMask::Format format = (SkMask::Format)glyph.fMaskFormat;
+    switch (glyph.getGlyphID() % 4) {
+        case 0:
+            format = SkMask::kLCD16_Format;
+            break;
+        case 1:
+            format = SkMask::kA8_Format;
+            break;
+        case 2:
+            format = SkMask::kARGB32_Format;
+            break;
+        case 3:
+            format = SkMask::kBW_Format;
+            break;
+    }
+    const_cast<SkGlyph&>(glyph).fMaskFormat = format;
+
+    // if the format is ARGB, we just draw the glyph from path ourselves.  Otherwise, we force
+    // our proxy context to generate the image from paths.
+    if (!fFakeIt) {
+        if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
+            SkPath path;
+            fProxy->getPath(glyph, &path);
+
+            SkBitmap bm;
+            bm.installPixels(SkImageInfo::MakeN32Premul(glyph.fWidth, glyph.fHeight),
+                             glyph.fImage, glyph.rowBytes());
+            bm.eraseColor(0);
+
+            SkCanvas canvas(bm);
+            canvas.translate(-SkIntToScalar(glyph.fLeft),
+                             -SkIntToScalar(glyph.fTop));
+            canvas.drawPath(path, fFace->paint());
+        } else {
+            fProxy->forceGenerateImageFromPath();
+            fProxy->getImage(glyph);
+            fProxy->forceOffGenerateImageFromPath();
+        }
+    } else {
+        sk_bzero(glyph.fImage, glyph.computeImageSize());
+    }
+}
+
+void SkRandomScalerContext::generatePath(const SkGlyph& glyph, SkPath* path) {
+    fProxy->getPath(glyph, path);
+}
+
+void SkRandomScalerContext::generateFontMetrics(SkPaint::FontMetrics* metrics) {
+    fProxy->getFontMetrics(metrics);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkTypefaceCache.h"
+
+SkRandomTypeface::SkRandomTypeface(SkTypeface* proxy, const SkPaint& paint, bool fakeIt)
+    : SkTypeface(proxy->fontStyle(), SkTypefaceCache::NewFontID(), false)
+    , fProxy(SkRef(proxy))
+    , fPaint(paint)
+    , fFakeIt(fakeIt) {}
+
+SkRandomTypeface::~SkRandomTypeface() {
+    fProxy->unref();
+}
+
+SkScalerContext* SkRandomTypeface::onCreateScalerContext(
+                                            const SkDescriptor* desc) const {
+    return SkNEW_ARGS(SkRandomScalerContext, (const_cast<SkRandomTypeface*>(this), desc, fFakeIt));
+}
+
+void SkRandomTypeface::onFilterRec(SkScalerContextRec* rec) const {
+    fProxy->filterRec(rec);
+    rec->setHinting(SkPaint::kNo_Hinting);
+    rec->fMaskFormat = SkMask::kARGB32_Format;
+}
+
+SkAdvancedTypefaceMetrics* SkRandomTypeface::onGetAdvancedTypefaceMetrics(
+                                PerGlyphInfo info,
+                                const uint32_t* glyphIDs,
+                                uint32_t glyphIDsCount) const {
+    return fProxy->getAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount);
+}
+
+SkStreamAsset* SkRandomTypeface::onOpenStream(int* ttcIndex) const {
+    return fProxy->openStream(ttcIndex);
+}
+
+void SkRandomTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
+                                      bool* isLocal) const {
+    fProxy->getFontDescriptor(desc, isLocal);
+}
+
+int SkRandomTypeface::onCharsToGlyphs(const void* chars, Encoding encoding,
+                                 uint16_t glyphs[], int glyphCount) const {
+    return fProxy->charsToGlyphs(chars, encoding, glyphs, glyphCount);
+}
+
+int SkRandomTypeface::onCountGlyphs() const {
+    return fProxy->countGlyphs();
+}
+
+int SkRandomTypeface::onGetUPEM() const {
+    return fProxy->getUnitsPerEm();
+}
+
+void SkRandomTypeface::onGetFamilyName(SkString* familyName) const {
+    fProxy->getFamilyName(familyName);
+}
+
+SkTypeface::LocalizedStrings* SkRandomTypeface::onCreateFamilyNameIterator() const {
+    return fProxy->createFamilyNameIterator();
+}
+
+int SkRandomTypeface::onGetTableTags(SkFontTableTag tags[]) const {
+    return fProxy->getTableTags(tags);
+}
+
+size_t SkRandomTypeface::onGetTableData(SkFontTableTag tag, size_t offset,
+                                    size_t length, void* data) const {
+    return fProxy->getTableData(tag, offset, length, data);
+}
+
diff --git a/src/fonts/SkRandomScalerContext.h b/src/fonts/SkRandomScalerContext.h
new file mode 100644
index 0000000..24b203f
--- /dev/null
+++ b/src/fonts/SkRandomScalerContext.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkRandomScalerContext_DEFINED
+#define SkRandomScalerContext_DEFINED
+
+#include "SkScalerContext.h"
+#include "SkTypeface.h"
+
+/*
+ * This scaler context is for debug only purposes.  It will 'randomly' but deterministically return
+ * LCD / A8 / BW / RBGA masks based off of the Glyph ID
+ */
+
+class SkRandomTypeface : public SkTypeface {
+public:
+    SkRandomTypeface(SkTypeface* proxy, const SkPaint&, bool fakeit);
+    virtual ~SkRandomTypeface();
+
+    SkTypeface* proxy() const { return fProxy; }
+    const SkPaint& paint() const { return fPaint; }
+
+protected:
+    SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override;
+    void onFilterRec(SkScalerContextRec*) const override;
+    SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
+        PerGlyphInfo,
+        const uint32_t* glyphIDs,
+        uint32_t glyphIDsCount) const override;
+    SkStreamAsset* onOpenStream(int* ttcIndex) const override;
+    void onGetFontDescriptor(SkFontDescriptor*, bool* isLocal) const override;
+
+    int onCharsToGlyphs(const void* chars, Encoding encoding,
+                        uint16_t glyphs[], int glyphCount) const override;
+    int onCountGlyphs() const override;
+    int onGetUPEM() const override;
+
+    void onGetFamilyName(SkString* familyName) const override;
+    SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override;
+
+    int onGetTableTags(SkFontTableTag tags[]) const override;
+    size_t onGetTableData(SkFontTableTag, size_t offset,
+                          size_t length, void* data) const override;
+
+private:
+    SkTypeface* fProxy;
+    SkPaint     fPaint;
+    bool        fFakeIt;
+};
+
+#endif
diff --git a/src/gpu/GrAtlasTextContext.cpp b/src/gpu/GrAtlasTextContext.cpp
index b562014..bc015ea 100644
--- a/src/gpu/GrAtlasTextContext.cpp
+++ b/src/gpu/GrAtlasTextContext.cpp
@@ -875,10 +875,7 @@
         if (glyph.fWidth) {
             this->bmpAppendGlyph(blob,
                                  runIndex,
-                                 GrGlyph::Pack(glyph.getGlyphID(),
-                                               glyph.getSubXFixed(),
-                                               glyph.getSubYFixed(),
-                                               GrGlyph::kCoverage_MaskStyle),
+                                 glyph,
                                  Sk48Dot16FloorToInt(fx),
                                  Sk48Dot16FloorToInt(fy),
                                  color,
@@ -945,10 +942,7 @@
                 if (glyph.fWidth) {
                     this->bmpAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kCoverage_MaskStyle),
+                                         glyph,
                                          Sk48Dot16FloorToInt(fx),
                                          Sk48Dot16FloorToInt(fy),
                                          color,
@@ -983,10 +977,7 @@
 
                     this->bmpAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kCoverage_MaskStyle),
+                                         glyph,
                                          Sk48Dot16FloorToInt(fx),
                                          Sk48Dot16FloorToInt(fy),
                                          color,
@@ -1011,10 +1002,7 @@
                     Sk48Dot16 fy = SkScalarTo48Dot16(tmsLoc.fY + SK_ScalarHalf); //halfSampleY;
                     this->bmpAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kCoverage_MaskStyle),
+                                         glyph,
                                          Sk48Dot16FloorToInt(fx),
                                          Sk48Dot16FloorToInt(fy),
                                          color,
@@ -1039,10 +1027,7 @@
                     Sk48Dot16 fy = SkScalarTo48Dot16(alignLoc.fY + SK_ScalarHalf); //halfSampleY;
                     this->bmpAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kCoverage_MaskStyle),
+                                         glyph,
                                          Sk48Dot16FloorToInt(fx),
                                          Sk48Dot16FloorToInt(fy),
                                          color,
@@ -1168,10 +1153,7 @@
 
                 if (!this->dfAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kDistance_MaskStyle),
+                                         glyph,
                                          x, y, color, fontScaler, clipRect,
                                          textRatio, viewMatrix)) {
                     // couldn't append, send to fallback
@@ -1201,10 +1183,7 @@
 
                 if (!this->dfAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kDistance_MaskStyle),
+                                         glyph,
                                          x - advanceX, y - advanceY, color,
                                          fontScaler,
                                          clipRect,
@@ -1224,16 +1203,19 @@
 }
 
 void GrAtlasTextContext::bmpAppendGlyph(BitmapTextBlob* blob, int runIndex,
-                                        GrGlyph::PackedID packed,
+                                        const SkGlyph& skGlyph,
                                         int vx, int vy, GrColor color, GrFontScaler* scaler,
                                         const SkIRect& clipRect) {
     Run& run = blob->fRuns[runIndex];
     if (!fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
-        run.fStrike.reset(SkRef(fCurrStrike));
     }
 
-    GrGlyph* glyph = fCurrStrike->getGlyph(packed, scaler);
+    GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
+                                         skGlyph.getSubXFixed(),
+                                         skGlyph.getSubYFixed(),
+                                         GrGlyph::kCoverage_MaskStyle);
+    GrGlyph* glyph = fCurrStrike->getGlyph(skGlyph, id, scaler);
     if (!glyph) {
         return;
     }
@@ -1259,7 +1241,7 @@
 
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
-        this->appendGlyphPath(blob, glyph, scaler, SkIntToScalar(vx), SkIntToScalar(vy));
+        this->appendGlyphPath(blob, glyph, scaler, skGlyph, SkIntToScalar(vx), SkIntToScalar(vy));
         return;
     }
 
@@ -1267,7 +1249,10 @@
 
     PerSubRunInfo* subRun = &run.fSubRunInfo.back();
     if (run.fInitialized && subRun->fMaskFormat != format) {
-        subRun = &run.fSubRunInfo.push_back();
+        subRun = &run.push_back();
+        subRun->fStrike.reset(SkRef(fCurrStrike));
+    } else if (!run.fInitialized) {
+        subRun->fStrike.reset(SkRef(fCurrStrike));
     }
 
     run.fInitialized = true;
@@ -1285,7 +1270,7 @@
 }
 
 bool GrAtlasTextContext::dfAppendGlyph(BitmapTextBlob* blob, int runIndex,
-                                       GrGlyph::PackedID packed,
+                                       const SkGlyph& skGlyph,
                                        SkScalar sx, SkScalar sy, GrColor color,
                                        GrFontScaler* scaler,
                                        const SkIRect& clipRect,
@@ -1293,10 +1278,13 @@
     Run& run = blob->fRuns[runIndex];
     if (!fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
-        run.fStrike.reset(SkRef(fCurrStrike));
     }
 
-    GrGlyph* glyph = fCurrStrike->getGlyph(packed, scaler);
+    GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
+                                         skGlyph.getSubXFixed(),
+                                         skGlyph.getSubYFixed(),
+                                         GrGlyph::kDistance_MaskStyle);
+    GrGlyph* glyph = fCurrStrike->getGlyph(skGlyph, id, scaler);
     if (!glyph) {
         return true;
     }
@@ -1335,11 +1323,15 @@
     // TODO combine with the above
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
-        this->appendGlyphPath(blob, glyph, scaler, sx - dx, sy - dy);
+        this->appendGlyphPath(blob, glyph, scaler, skGlyph, sx - dx, sy - dy);
         return true;
     }
 
     PerSubRunInfo* subRun = &run.fSubRunInfo.back();
+    if (!run.fInitialized) {
+        subRun->fStrike.reset(SkRef(fCurrStrike));
+    }
+    run.fInitialized = true;
     SkASSERT(glyph->fMaskFormat == kA8_GrMaskFormat);
     subRun->fMaskFormat = kA8_GrMaskFormat;
 
@@ -1352,17 +1344,16 @@
 }
 
 inline void GrAtlasTextContext::appendGlyphPath(BitmapTextBlob* blob, GrGlyph* glyph,
-                                                GrFontScaler* scaler, SkScalar x, SkScalar y) {
+                                                GrFontScaler* scaler, const SkGlyph& skGlyph,
+                                                SkScalar x, SkScalar y) {
     if (NULL == glyph->fPath) {
-        SkPath* path = SkNEW(SkPath);
-        if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
-            // flag the glyph as being dead?
-            SkDELETE(path);
+        const SkPath* glyphPath = scaler->getGlyphPath(skGlyph);
+        if (!glyphPath) {
             return;
         }
-        glyph->fPath = path;
+
+        glyph->fPath = SkNEW_ARGS(SkPath, (*glyphPath));
     }
-    SkASSERT(glyph->fPath);
     blob->fBigGlyphs.push_back(BitmapTextBlob::BigGlyph(*glyph->fPath, x, y));
 }
 
@@ -1585,7 +1576,7 @@
 
             uint64_t currentAtlasGen = fFontCache->atlasGeneration(fMaskFormat);
             bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen ||
-                                           run.fStrike->isAbandoned();
+                                           info.fStrike->isAbandoned();
             bool regenerateColors;
             if (fUseDistanceFields) {
                 regenerateColors = !fUseLCDText && run.fColor != args.fColor;
@@ -1633,41 +1624,46 @@
                         desc = newDesc;
                         cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
                         scaler = GrTextContext::GetGrFontScaler(cache);
-                        strike = run.fStrike;
+                        strike = info.fStrike;
                         typeface = run.fTypeface;
                     }
 
-                    if (run.fStrike->isAbandoned()) {
+                    if (info.fStrike->isAbandoned()) {
                         regenerateGlyphs = true;
                         strike = fFontCache->getStrike(scaler);
                     } else {
-                        strike = run.fStrike;
+                        strike = info.fStrike;
                     }
                 }
 
                 for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
                     if (regenerateTextureCoords) {
                         size_t glyphOffset = glyphIdx + info.fGlyphStartIndex;
-                        GrGlyph* glyph;
+
+                        GrGlyph* glyph = blob->fGlyphs[glyphOffset];
+                        GrGlyph::PackedID id = glyph->fPackedID;
+                        const SkGlyph& skGlyph = scaler->grToSkGlyph(id);
                         if (regenerateGlyphs) {
                             // Get the id from the old glyph, and use the new strike to lookup
                             // the glyph.
-                            glyph = blob->fGlyphs[glyphOffset];
-                            blob->fGlyphs[glyphOffset] = strike->getGlyph(glyph->fPackedID,
+                            blob->fGlyphs[glyphOffset] = strike->getGlyph(skGlyph, id, fMaskFormat,
                                                                           scaler);
                         }
                         glyph = blob->fGlyphs[glyphOffset];
                         SkASSERT(glyph);
 
                         if (!fFontCache->hasGlyph(glyph) &&
-                            !strike->addGlyphToAtlas(batchTarget, glyph, scaler)) {
+                            !strike->addGlyphToAtlas(batchTarget, glyph, scaler, skGlyph,
+                                                     fMaskFormat)) {
                             this->flush(batchTarget, &flushInfo);
                             this->initDraw(batchTarget, gp, pipeline);
                             brokenRun = glyphIdx > 0;
 
                             SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(batchTarget,
                                                                                 glyph,
-                                                                                scaler);
+                                                                                scaler,
+                                                                                skGlyph,
+                                                                                fMaskFormat);
                             SkASSERT(success);
                         }
                         fFontCache->addGlyphToBulkAndSetUseToken(&info.fBulkUseToken, glyph,
@@ -1705,7 +1701,7 @@
                 run.fColor = args.fColor;
                 if (regenerateTextureCoords) {
                     if (regenerateGlyphs) {
-                        run.fStrike.reset(SkRef(strike));
+                        info.fStrike.reset(SkRef(strike));
                     }
                     info.fAtlasGeneration = brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
                                                         fFontCache->atlasGeneration(fMaskFormat);
diff --git a/src/gpu/GrAtlasTextContext.h b/src/gpu/GrAtlasTextContext.h
index eb7ba47..83ffa0e 100644
--- a/src/gpu/GrAtlasTextContext.h
+++ b/src/gpu/GrAtlasTextContext.h
@@ -109,6 +109,19 @@
                     , fGlyphStartIndex(0)
                     , fGlyphEndIndex(0)
                     , fDrawAsDistanceFields(false) {}
+                SubRunInfo(const SubRunInfo& that)
+                    : fBulkUseToken(that.fBulkUseToken)
+                    , fStrike(SkSafeRef(that.fStrike.get()))
+                    , fAtlasGeneration(that.fAtlasGeneration)
+                    , fVertexStartIndex(that.fVertexStartIndex)
+                    , fVertexEndIndex(that.fVertexEndIndex)
+                    , fGlyphStartIndex(that.fGlyphStartIndex)
+                    , fGlyphEndIndex(that.fGlyphEndIndex)
+                    , fTextRatio(that.fTextRatio)
+                    , fMaskFormat(that.fMaskFormat)
+                    , fDrawAsDistanceFields(that.fDrawAsDistanceFields)
+                    , fUseLCDText(that.fUseLCDText) {
+                }
                 // Distance field text cannot draw coloremoji, and so has to fall back.  However,
                 // though the distance field text and the coloremoji may share the same run, they
                 // will have different descriptors.  If fOverrideDescriptor is non-NULL, then it
@@ -117,6 +130,7 @@
                 // significantly, and then the subrun could just have a refed pointer to the
                 // correct descriptor.
                 GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
+                SkAutoTUnref<GrBatchTextStrike> fStrike;
                 uint64_t fAtlasGeneration;
                 size_t fVertexStartIndex;
                 size_t fVertexEndIndex;
@@ -130,8 +144,9 @@
 
             SubRunInfo& push_back() {
                 // Forward glyph / vertex information to seed the new sub run
-                SubRunInfo& prevSubRun = fSubRunInfo.back();
                 SubRunInfo& newSubRun = fSubRunInfo.push_back();
+                SubRunInfo& prevSubRun = fSubRunInfo.fromBack(1);
+
                 newSubRun.fGlyphStartIndex = prevSubRun.fGlyphEndIndex;
                 newSubRun.fGlyphEndIndex = prevSubRun.fGlyphEndIndex;
 
@@ -140,7 +155,6 @@
                 return newSubRun;
             }
             static const int kMinSubRuns = 1;
-            SkAutoTUnref<GrBatchTextStrike> fStrike;
             SkAutoTUnref<SkTypeface> fTypeface;
             SkRect fVertexBounds;
             SkSTArray<kMinSubRuns, SubRunInfo> fSubRunInfo;
@@ -259,13 +273,13 @@
     BitmapTextBlob* setupDFBlob(int glyphCount, const SkPaint& origPaint,
                                 const SkMatrix& viewMatrix, SkGlyphCache** cache,
                                 SkPaint* dfPaint, SkScalar* textRatio);
-    void bmpAppendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, int left, int top,
+    void bmpAppendGlyph(BitmapTextBlob*, int runIndex, const SkGlyph&, int left, int top,
                         GrColor color, GrFontScaler*, const SkIRect& clipRect);
-    bool dfAppendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, SkScalar sx, SkScalar sy,
+    bool dfAppendGlyph(BitmapTextBlob*, int runIndex, const SkGlyph&, SkScalar sx, SkScalar sy,
                        GrColor color, GrFontScaler*, const SkIRect& clipRect, SkScalar textRatio,
                        const SkMatrix& viewMatrix);
-    inline void appendGlyphPath(BitmapTextBlob* blob, GrGlyph* glyph,
-                                GrFontScaler* scaler, SkScalar x, SkScalar y);
+    inline void appendGlyphPath(BitmapTextBlob*, GrGlyph*, GrFontScaler*, const SkGlyph&,
+                                SkScalar x, SkScalar y);
     inline void appendGlyphCommon(BitmapTextBlob*, Run*, Run::SubRunInfo*,
                                   const SkRect& positions, GrColor color,
                                   size_t vertexStride, bool useVertexColor,
diff --git a/src/gpu/GrBatchAtlas.cpp b/src/gpu/GrBatchAtlas.cpp
index 20e73e4..7d84757 100644
--- a/src/gpu/GrBatchAtlas.cpp
+++ b/src/gpu/GrBatchAtlas.cpp
@@ -17,9 +17,9 @@
     loc->fY += offset.fY;
 }
 
-static GrBatchAtlas::AtlasID create_id(int index, int generation) {
-    // Generation ID can roll over because we only check for equality
+static GrBatchAtlas::AtlasID create_id(uint32_t index, uint64_t generation) {
     SkASSERT(index < (1 << 16));
+    SkASSERT(generation < ((uint64_t)1 << 48));
     return generation << 16 | index;
 }
 
@@ -40,8 +40,8 @@
     // monotonically incrementing number which is bumped every time the cpu backing store is
     // wiped, or when the plot itself is evicted from the atlas(ie, there is continuity in genID()
     // across atlas spills)
-    int index() const { return fIndex; }
-    int genID() const { return fGenID; }
+    uint32_t index() const { return fIndex; }
+    uint64_t genID() const { return fGenID; }
     GrBatchAtlas::AtlasID id() { return fID; }
 
     GrTexture* texture() const { return fTexture; }
@@ -121,8 +121,8 @@
         SkDEBUGCODE(fDirty = false;)
     }
 
-    int x() const { return fX; }
-    int y() const { return fY; }
+    uint32_t x() const { return fX; }
+    uint32_t y() const { return fY; }
 
 private:
     BatchPlot()
@@ -153,7 +153,7 @@
         delete fRects;
     }
 
-    void init(GrBatchAtlas* atlas, GrTexture* texture, int index, uint32_t generation,
+    void init(GrBatchAtlas* atlas, GrTexture* texture, int index, uint64_t generation,
               int offX, int offY, int width, int height, size_t bpp) {
         fIndex = index;
         fGenID = generation;
@@ -176,13 +176,13 @@
     BatchToken fLastUse;
 
     uint32_t fIndex;
-    uint32_t fGenID;
+    uint64_t fGenID;
     GrBatchAtlas::AtlasID fID;
     unsigned char* fData;
-    int fWidth;
-    int fHeight;
-    int fX;
-    int fY;
+    uint32_t fWidth;
+    uint32_t fHeight;
+    uint32_t fX;
+    uint32_t fY;
     GrTexture* fTexture;
     GrRectanizer* fRects;
     GrBatchAtlas* fAtlas;
@@ -226,8 +226,8 @@
     , fPlotHeight(texture->height() / numPlotsY)
     , fAtlasGeneration(kInvalidAtlasGeneration + 1) {
     SkASSERT(fNumPlotsX * fNumPlotsY <= BulkUseTokenUpdater::kMaxPlots);
-    SkASSERT(fPlotWidth * fNumPlotsX == texture->width());
-    SkASSERT(fPlotHeight * fNumPlotsY == texture->height());
+    SkASSERT(fPlotWidth * fNumPlotsX == static_cast<uint32_t>(texture->width()));
+    SkASSERT(fPlotHeight * fNumPlotsY == static_cast<uint32_t>(texture->height()));
 
     // We currently do not support compressed atlases...
     SkASSERT(!GrPixelConfigIsCompressed(texture->desc().fConfig));
@@ -239,7 +239,7 @@
     SkAutoTUnref<BatchPlot>* currPlot = fPlotArray;
     for (int y = fNumPlotsY - 1, r = 0; y >= 0; --y, ++r) {
         for (int x = fNumPlotsX - 1, c = 0; x >= 0; --x, ++c) {
-            int id = r * fNumPlotsX + c;
+            uint32_t id = r * fNumPlotsX + c;
             currPlot->reset(SkNEW(BatchPlot));
             (*currPlot)->init(this, texture, id, 1, x, y, fPlotWidth, fPlotHeight, fBPP);
 
@@ -287,7 +287,9 @@
 bool GrBatchAtlas::addToAtlas(AtlasID* id, GrBatchTarget* batchTarget,
                               int width, int height, const void* image, SkIPoint16* loc) {
     // We should already have a texture, TODO clean this up
-    SkASSERT(fTexture && width <= fPlotWidth && height <= fPlotHeight);
+    SkASSERT(fTexture &&
+             static_cast<uint32_t>(width) <= fPlotWidth &&
+             static_cast<uint32_t>(height) <= fPlotHeight);
 
     // now look through all allocated plots for one we can share, in Most Recently Refed order
     GrBatchPlotList::Iter plotIter;
@@ -331,7 +333,7 @@
     int index = plot->index();
     int x = plot->x();
     int y = plot->y();
-    int generation = plot->genID();
+    uint64_t generation = plot->genID();
 
     this->processEviction(plot->id());
     fPlotList.remove(plot);
@@ -352,14 +354,14 @@
 }
 
 bool GrBatchAtlas::hasID(AtlasID id) {
-    int index = GetIndexFromID(id);
+    uint32_t index = GetIndexFromID(id);
     SkASSERT(index < fNumPlotsX * fNumPlotsY);
     return fPlotArray[index]->genID() == GetGenerationFromID(id);
 }
 
 void GrBatchAtlas::setLastUseToken(AtlasID id, BatchToken batchToken) {
     SkASSERT(this->hasID(id));
-    int index = GetIndexFromID(id);
+    uint32_t index = GetIndexFromID(id);
     SkASSERT(index < fNumPlotsX * fNumPlotsY);
     this->makeMRU(fPlotArray[index]);
     fPlotArray[index]->setLastUseToken(batchToken);
diff --git a/src/gpu/GrBatchAtlas.h b/src/gpu/GrBatchAtlas.h
index 83ef5ec..4d21394 100644
--- a/src/gpu/GrBatchAtlas.h
+++ b/src/gpu/GrBatchAtlas.h
@@ -24,7 +24,7 @@
     typedef uint64_t BatchToken;
     // An AtlasID is an opaque handle which callers can use to determine if the atlas contains
     // a specific piece of data
-    typedef uint32_t AtlasID;
+    typedef uint64_t AtlasID;
     static const uint32_t kInvalidAtlasID = 0;
     static const uint64_t kInvalidAtlasGeneration = 0;
 
@@ -67,6 +67,11 @@
     class BulkUseTokenUpdater {
     public:
         BulkUseTokenUpdater() : fPlotAlreadyUpdated(0) {}
+        BulkUseTokenUpdater(const BulkUseTokenUpdater& that)
+        : fPlotsToUpdate(that.fPlotsToUpdate)
+        , fPlotAlreadyUpdated(that.fPlotAlreadyUpdated) {
+        }
+
         void add(AtlasID id) {
             int index = GrBatchAtlas::GetIndexFromID(id);
             if (!this->find(index)) {
@@ -107,12 +112,13 @@
     }
 
 private:
-    static int GetIndexFromID(AtlasID id) {
+    static uint32_t GetIndexFromID(AtlasID id) {
         return id & 0xffff;
     }
 
-    static int GetGenerationFromID(AtlasID id) {
-        return (id >> 16) & 0xffff;
+    // top 48 bits are reserved for the generation ID
+    static uint64_t GetGenerationFromID(AtlasID id) {
+        return (id >> 16) & 0xffffffffffff;
     }
 
     inline void updatePlot(GrBatchTarget*, AtlasID*, BatchPlot*);
@@ -122,10 +128,10 @@
     inline void processEviction(AtlasID);
 
     GrTexture* fTexture;
-    int fNumPlotsX;
-    int fNumPlotsY;
-    int fPlotWidth;
-    int fPlotHeight;
+    uint32_t fNumPlotsX;
+    uint32_t fNumPlotsY;
+    uint32_t fPlotWidth;
+    uint32_t fPlotHeight;
     size_t fBPP;
     uint64_t fAtlasGeneration;
 
diff --git a/src/gpu/GrBatchFontCache.cpp b/src/gpu/GrBatchFontCache.cpp
index 2d6213c..007f18a 100644
--- a/src/gpu/GrBatchFontCache.cpp
+++ b/src/gpu/GrBatchFontCache.cpp
@@ -173,20 +173,20 @@
     }
 }
 
-GrGlyph* GrBatchTextStrike::generateGlyph(GrGlyph::PackedID packed,
+GrGlyph* GrBatchTextStrike::generateGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
                                           GrFontScaler* scaler) {
     SkIRect bounds;
     if (GrGlyph::kDistance_MaskStyle == GrGlyph::UnpackMaskStyle(packed)) {
-        if (!scaler->getPackedGlyphDFBounds(packed, &bounds)) {
+        if (!scaler->getPackedGlyphDFBounds(skGlyph, &bounds)) {
             return NULL;
         }
     } else {
-        if (!scaler->getPackedGlyphBounds(packed, &bounds)) {
+        if (!scaler->getPackedGlyphBounds(skGlyph, &bounds)) {
             return NULL;
         }
     }
-    GrMaskFormat format = scaler->getPackedGlyphMaskFormat(packed);
-    
+    GrMaskFormat format = scaler->getPackedGlyphMaskFormat(skGlyph);
+
     GrGlyph* glyph = (GrGlyph*)fPool.alloc(sizeof(GrGlyph), SK_MALLOC_THROW);
     glyph->init(packed, bounds, format);
     fCache.add(glyph);
@@ -206,7 +206,8 @@
 }
 
 bool GrBatchTextStrike::addGlyphToAtlas(GrBatchTarget* batchTarget, GrGlyph* glyph,
-                                        GrFontScaler* scaler) {
+                                        GrFontScaler* scaler, const SkGlyph& skGlyph,
+                                        GrMaskFormat expectedMaskFormat) {
     SkASSERT(glyph);
     SkASSERT(scaler);
     SkASSERT(fCache.find(glyph->fPackedID));
@@ -214,27 +215,25 @@
 
     SkAutoUnref ar(SkSafeRef(scaler));
 
-    int bytesPerPixel = GrMaskFormatBytesPerPixel(glyph->fMaskFormat);
+    int bytesPerPixel = GrMaskFormatBytesPerPixel(expectedMaskFormat);
 
     size_t size = glyph->fBounds.area() * bytesPerPixel;
     GrAutoMalloc<1024> storage(size);
 
     if (GrGlyph::kDistance_MaskStyle == GrGlyph::UnpackMaskStyle(glyph->fPackedID)) {
-        if (!scaler->getPackedGlyphDFImage(glyph->fPackedID, glyph->width(),
-                                           glyph->height(),
+        if (!scaler->getPackedGlyphDFImage(skGlyph, glyph->width(), glyph->height(),
                                            storage.get())) {
             return false;
         }
     } else {
-        if (!scaler->getPackedGlyphImage(glyph->fPackedID, glyph->width(),
-                                         glyph->height(),
-                                         glyph->width() * bytesPerPixel,
+        if (!scaler->getPackedGlyphImage(skGlyph, glyph->width(), glyph->height(),
+                                         glyph->width() * bytesPerPixel, expectedMaskFormat,
                                          storage.get())) {
             return false;
         }
     }
 
-    bool success = fBatchFontCache->addToAtlas(this, &glyph->fID, batchTarget, glyph->fMaskFormat,
+    bool success = fBatchFontCache->addToAtlas(this, &glyph->fID, batchTarget, expectedMaskFormat,
                                                glyph->width(), glyph->height(),
                                                storage.get(), &glyph->fAtlasLocation);
     if (success) {
diff --git a/src/gpu/GrBatchFontCache.h b/src/gpu/GrBatchFontCache.h
index f1c56ac..f6617d0 100644
--- a/src/gpu/GrBatchFontCache.h
+++ b/src/gpu/GrBatchFontCache.h
@@ -12,6 +12,7 @@
 #include "GrDrawTarget.h"
 #include "GrFontScaler.h"
 #include "GrGlyph.h"
+#include "SkGlyph.h"
 #include "SkTDynamicHash.h"
 #include "SkVarAlloc.h"
 
@@ -32,16 +33,36 @@
     const GrFontDescKey* getFontScalerKey() const { return fFontScalerKey; }
     GrBatchFontCache* getBatchFontCache() const { return fBatchFontCache; }
 
-    inline GrGlyph* getGlyph(GrGlyph::PackedID packed, GrFontScaler* scaler) {
+    inline GrGlyph* getGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
+                             GrFontScaler* scaler) {
         GrGlyph* glyph = fCache.find(packed);
         if (NULL == glyph) {
-            glyph = this->generateGlyph(packed, scaler);
+            glyph = this->generateGlyph(skGlyph, packed, scaler);
         }
         return glyph;
     }
 
-    // returns true if glyph successfully added to texture atlas, false otherwise
-    bool addGlyphToAtlas(GrBatchTarget*, GrGlyph*, GrFontScaler*);
+    // This variant of the above function is called by TextBatch.  At this point, it is possible
+    // that the maskformat of the glyph differs from what we expect.  In these cases we will just
+    // draw a clear square.
+    // skbug:4143 crbug:510931
+    inline GrGlyph* getGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
+                             GrMaskFormat expectedMaskFormat, GrFontScaler* scaler) {
+        GrGlyph* glyph = fCache.find(packed);
+        if (NULL == glyph) {
+            glyph = this->generateGlyph(skGlyph, packed, scaler);
+            glyph->fMaskFormat = expectedMaskFormat;
+        }
+        return glyph;
+    }
+
+    // returns true if glyph successfully added to texture atlas, false otherwise.  If the glyph's
+    // mask format has changed, then addGlyphToAtlas will draw a clear box.  This will almost never
+    // happen.
+    // TODO we can handle some of these cases if we really want to, but the long term solution is to
+    // get the actual glyph image itself when we get the glyph metrics.
+    bool addGlyphToAtlas(GrBatchTarget*, GrGlyph*, GrFontScaler*, const SkGlyph&,
+                         GrMaskFormat expectedMaskFormat);
 
     // testing
     int countGlyphs() const { return fCache.count(); }
@@ -68,7 +89,7 @@
     int fAtlasedGlyphs;
     bool fIsAbandoned;
 
-    GrGlyph* generateGlyph(GrGlyph::PackedID packed, GrFontScaler* scaler);
+    GrGlyph* generateGlyph(const SkGlyph&, GrGlyph::PackedID, GrFontScaler*);
 
     friend class GrBatchFontCache;
 };
diff --git a/src/gpu/GrFontScaler.cpp b/src/gpu/GrFontScaler.cpp
index ed1970e..1d228a4 100644
--- a/src/gpu/GrFontScaler.cpp
+++ b/src/gpu/GrFontScaler.cpp
@@ -83,10 +83,7 @@
     return fKey;
 }
 
-GrMaskFormat GrFontScaler::getPackedGlyphMaskFormat(GrGlyph::PackedID packed) const {
-    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
-                                                      GrGlyph::UnpackFixedX(packed),
-                                                      GrGlyph::UnpackFixedY(packed));
+GrMaskFormat GrFontScaler::getPackedGlyphMaskFormat(const SkGlyph& glyph) const {
     SkMask::Format format = static_cast<SkMask::Format>(glyph.fMaskFormat);
     switch (format) {
         case SkMask::kBW_Format:
@@ -103,19 +100,23 @@
     }
 }
 
-bool GrFontScaler::getPackedGlyphBounds(GrGlyph::PackedID packed, SkIRect* bounds) {
-    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
-                                                      GrGlyph::UnpackFixedX(packed),
-                                                      GrGlyph::UnpackFixedY(packed));
+bool GrFontScaler::getPackedGlyphBounds(const SkGlyph& glyph, SkIRect* bounds) {
+#if 1
+    // crbug:510931
+    // Retrieving the image from the cache can actually change the mask format.
+    fStrike->findImage(glyph);
+#endif
     bounds->setXYWH(glyph.fLeft, glyph.fTop, glyph.fWidth, glyph.fHeight);
 
     return true;
 }
 
-bool GrFontScaler::getPackedGlyphDFBounds(GrGlyph::PackedID packed, SkIRect* bounds) {
-    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
-                                                      GrGlyph::UnpackFixedX(packed),
-                                                      GrGlyph::UnpackFixedY(packed));
+bool GrFontScaler::getPackedGlyphDFBounds(const SkGlyph& glyph, SkIRect* bounds) {
+#if 1
+    // crbug:510931
+    // Retrieving the image from the cache can actually change the mask format.
+    fStrike->findImage(glyph);
+#endif
     bounds->setXYWH(glyph.fLeft, glyph.fTop, glyph.fWidth, glyph.fHeight);
     bounds->outset(SK_DistanceFieldPad, SK_DistanceFieldPad);
 
@@ -148,12 +149,8 @@
 }
 }
 
-bool GrFontScaler::getPackedGlyphImage(GrGlyph::PackedID packed,
-                                         int width, int height,
-                                         int dstRB, void* dst) {
-    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
-                                                      GrGlyph::UnpackFixedX(packed),
-                                                      GrGlyph::UnpackFixedY(packed));
+bool GrFontScaler::getPackedGlyphImage(const SkGlyph& glyph, int width, int height, int dstRB,
+                                       GrMaskFormat expectedMaskFormat, void* dst) {
     SkASSERT(glyph.fWidth == width);
     SkASSERT(glyph.fHeight == height);
     const void* src = fStrike->findImage(glyph);
@@ -161,6 +158,18 @@
         return false;
     }
 
+    // crbug:510931
+    // Retrieving the image from the cache can actually change the mask format.  This case is very
+    // uncommon so for now we just draw a clear box for these glyphs.
+    if (getPackedGlyphMaskFormat(glyph) != expectedMaskFormat) {
+        const int bpp = GrMaskFormatBytesPerPixel(expectedMaskFormat);
+        for (int y = 0; y < height; y++) {
+            sk_bzero(dst, width * bpp);
+            dst = (char*)dst + dstRB;
+        }
+        return true;
+    }
+
     int srcRB = glyph.rowBytes();
     // The windows font host sometimes has BW glyphs in a non-BW strike. So it is important here to
     // check the glyph's format, not the strike's format, and to be able to convert to any of the
@@ -168,7 +177,7 @@
     if (SkMask::kBW_Format == glyph.fMaskFormat) {
         // expand bits to our mask type
         const uint8_t* bits = reinterpret_cast<const uint8_t*>(src);
-        switch (this->getMaskFormat()) {
+        switch (expectedMaskFormat) {
             case kA8_GrMaskFormat:{
                 uint8_t* bytes = reinterpret_cast<uint8_t*>(dst);
                 expand_bits(bytes, bits, width, height, dstRB, srcRB);
@@ -185,7 +194,7 @@
     } else if (srcRB == dstRB) {
         memcpy(dst, src, dstRB * height);
     } else {
-        const int bbp = GrMaskFormatBytesPerPixel(this->getMaskFormat());
+        const int bbp = GrMaskFormatBytesPerPixel(expectedMaskFormat);
         for (int y = 0; y < height; y++) {
             memcpy(dst, src, width * bbp);
             src = (const char*)src + srcRB;
@@ -195,12 +204,7 @@
     return true;
 }
 
-bool GrFontScaler::getPackedGlyphDFImage(GrGlyph::PackedID packed,
-                                         int width, int height,
-                                         void* dst) {
-    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
-                                                      GrGlyph::UnpackFixedX(packed),
-                                                      GrGlyph::UnpackFixedY(packed));
+bool GrFontScaler::getPackedGlyphDFImage(const SkGlyph& glyph, int width, int height, void* dst) {
     SkASSERT(glyph.fWidth + 2*SK_DistanceFieldPad == width);
     SkASSERT(glyph.fHeight + 2*SK_DistanceFieldPad == height);
     const void* image = fStrike->findImage(glyph);
@@ -229,14 +233,12 @@
     return true;
 }
 
-// we should just return const SkPath* (NULL means false)
-bool GrFontScaler::getGlyphPath(uint16_t glyphID, SkPath* path) {
+const SkPath* GrFontScaler::getGlyphPath(const SkGlyph& glyph) {
+    return fStrike->findPath(glyph);
+}
 
-    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(glyphID);
-    const SkPath* skPath = fStrike->findPath(glyph);
-    if (skPath) {
-        *path = *skPath;
-        return true;
-    }
-    return false;
+const SkGlyph& GrFontScaler::grToSkGlyph(GrGlyph::PackedID id) {
+    return fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(id),
+                                      GrGlyph::UnpackFixedX(id),
+                                      GrGlyph::UnpackFixedY(id));
 }
diff --git a/src/gpu/GrFontScaler.h b/src/gpu/GrFontScaler.h
index 54d1e3f..eb93d91 100644
--- a/src/gpu/GrFontScaler.h
+++ b/src/gpu/GrFontScaler.h
@@ -13,6 +13,7 @@
 
 #include "SkDescriptor.h"
 
+class SkGlyph;
 class SkPath;
 
 /*
@@ -67,14 +68,14 @@
     
     const GrFontDescKey* getKey();
     GrMaskFormat getMaskFormat() const;
-    GrMaskFormat getPackedGlyphMaskFormat(GrGlyph::PackedID) const;
-    bool getPackedGlyphBounds(GrGlyph::PackedID, SkIRect* bounds);
-    bool getPackedGlyphImage(GrGlyph::PackedID, int width, int height,
-                                     int rowBytes, void* image);
-    bool getPackedGlyphDFBounds(GrGlyph::PackedID, SkIRect* bounds);
-    bool getPackedGlyphDFImage(GrGlyph::PackedID, int width, int height,
-                                       void* image);
-    bool getGlyphPath(uint16_t glyphID, SkPath*);
+    GrMaskFormat getPackedGlyphMaskFormat(const SkGlyph&) const;
+    bool getPackedGlyphBounds(const SkGlyph&, SkIRect* bounds);
+    bool getPackedGlyphImage(const SkGlyph&, int width, int height, int rowBytes,
+                             GrMaskFormat expectedMaskFormat, void* image);
+    bool getPackedGlyphDFBounds(const SkGlyph&, SkIRect* bounds);
+    bool getPackedGlyphDFImage(const SkGlyph&, int width, int height, void* image);
+    const SkPath* getGlyphPath(const SkGlyph&);
+    const SkGlyph& grToSkGlyph(GrGlyph::PackedID);
     
 private:
     SkGlyphCache*  fStrike;
diff --git a/tests/TextBlobCacheTest.cpp b/tests/TextBlobCacheTest.cpp
new file mode 100644
index 0000000..c063040
--- /dev/null
+++ b/tests/TextBlobCacheTest.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "sk_tool_utils.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkPoint.h"
+#include "SkTextBlob.h"
+#include "SkFontMgr.h"
+#include "SkGraphics.h"
+#include "SkSurface.h"
+#include "SkTypeface.h"
+#include "../src/fonts/SkRandomScalerContext.h"
+
+#ifdef SK_BUILD_FOR_WIN
+    #include "SkTypeface_win.h"
+#endif
+
+#include "Test.h"
+
+#if SK_SUPPORT_GPU
+#include "GrContextFactory.h"
+
+struct TextBlobWrapper {
+    // This class assumes it 'owns' the textblob it wraps, and thus does not need to take a ref
+    explicit TextBlobWrapper(const SkTextBlob* blob) : fBlob(blob) {}
+    TextBlobWrapper(const TextBlobWrapper& blob) : fBlob(SkRef(blob.fBlob.get())) {}
+
+    SkAutoTUnref<const SkTextBlob> fBlob;
+};
+
+static void draw(SkCanvas* canvas, int redraw, const SkTArray<TextBlobWrapper>& blobs) {
+    int yOffset = 0;
+    for (int r = 0; r < redraw; r++) {
+        for (int i = 0; i < blobs.count(); i++) {
+            const SkTextBlob* blob = blobs[i].fBlob.get();
+            const SkRect& bounds = blob->bounds();
+            yOffset += SkScalarCeilToInt(bounds.height());
+            SkPaint paint;
+            canvas->drawTextBlob(blob, 0, SkIntToScalar(yOffset), paint);
+        }
+    }
+}
+
+static const int kWidth = 1024;
+static const int kHeight = 768;
+
+// This test hammers the GPU textblobcache and font atlas
+static void text_blob_cache_inner(skiatest::Reporter* reporter, GrContextFactory* factory,
+                                  int maxTotalText, int maxGlyphID, int maxFamilies, bool normal) {
+    // setup surface
+    uint32_t flags = 0;
+    SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
+
+    // We don't typically actually draw with this unittest
+    GrContext* ctx = factory->get(GrContextFactory::kNull_GLContextType);
+    SkImageInfo info = SkImageInfo::Make(kWidth, kHeight, kN32_SkColorType, kPremul_SkAlphaType);
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info,
+                                                               0, &props));
+    REPORTER_ASSERT(reporter, surface);
+    if (!surface) {
+        return;
+    }
+
+    SkCanvas* canvas = surface->getCanvas();
+
+    SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
+
+    int count = SkMin32(fm->countFamilies(), maxFamilies);
+
+    // make a ton of text
+    SkAutoTArray<uint16_t> text(maxTotalText);
+    for (int i = 0; i < maxTotalText; i++) {
+        text[i] = i % maxGlyphID;
+    }
+
+    // generate textblobs
+    SkTArray<TextBlobWrapper> blobs;
+    for (int i = 0; i < count; i++) {
+        SkPaint paint;
+        paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+        paint.setTextSize(48); // draw big glyphs to really stress the atlas
+
+        SkString familyName;
+        fm->getFamilyName(i, &familyName);
+        SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
+        for (int j = 0; j < set->count(); ++j) {
+            SkFontStyle fs;
+            set->getStyle(j, &fs, NULL);
+
+            // We use a typeface which randomy returns unexpected mask formats to fuzz
+            SkAutoTUnref<SkTypeface> orig(set->createTypeface(j));
+            if (normal) {
+                paint.setTypeface(orig);
+            } else {
+                SkAutoTUnref<SkTypeface> typeface(SkNEW_ARGS(SkRandomTypeface, (orig, paint, true)));
+                paint.setTypeface(typeface);
+            }
+
+            SkTextBlobBuilder builder;
+            for (int aa = 0; aa < 2; aa++) {
+                for (int subpixel = 0; subpixel < 2; subpixel++) {
+                    for (int lcd = 0; lcd < 2; lcd++) {
+                        paint.setAntiAlias(SkToBool(aa));
+                        paint.setSubpixelText(SkToBool(subpixel));
+                        paint.setLCDRenderText(SkToBool(lcd));
+                        if (!SkToBool(lcd)) {
+                            paint.setTextSize(160);
+                        }
+                        const SkTextBlobBuilder::RunBuffer& run = builder.allocRun(paint,
+                                                                                   maxTotalText,
+                                                                                   0, 0,
+                                                                                   NULL);
+                        memcpy(run.glyphs, text.get(), maxTotalText * sizeof(uint16_t));
+                    }
+                }
+            }
+            SkNEW_APPEND_TO_TARRAY(&blobs, TextBlobWrapper, (builder.build()));
+        }
+    }
+
+    // create surface where LCD is impossible
+    info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
+    SkSurfaceProps propsNoLCD(0, kUnknown_SkPixelGeometry);
+    SkAutoTUnref<SkSurface> surfaceNoLCD(canvas->newSurface(info, &propsNoLCD));
+    REPORTER_ASSERT(reporter, surface);
+    if (!surface) {
+        return;
+    }
+
+    SkCanvas* canvasNoLCD = surfaceNoLCD->getCanvas();
+
+    // test redraw
+    draw(canvas, 2, blobs);
+    draw(canvasNoLCD, 2, blobs);
+
+    // test draw after free
+    ctx->freeGpuResources();
+    draw(canvas, 1, blobs);
+
+    ctx->freeGpuResources();
+    draw(canvasNoLCD, 1, blobs);
+
+    // test draw after abandon
+    ctx->abandonContext();
+    draw(canvas, 1, blobs);
+}
+
+DEF_GPUTEST(TextBlobCache, reporter, factory) {
+    text_blob_cache_inner(reporter, factory, 4096, 256, 30, true);
+}
+
+DEF_GPUTEST(TextBlobAbnormal, reporter, factory) {
+#ifdef SK_BUILD_FOR_ANDROID
+    text_blob_cache_inner(reporter, factory, 256, 256, 30, false);
+#else
+    text_blob_cache_inner(reporter, factory, 512, 256, 30, false);
+#endif
+}
+#endif