Revert of Modifying TextBlobCacheTest to use SkRandomScalerContext (patchset #3 id:40001 of https://codereview.chromium.org/1266003002/)

Reason for revert:
breaking android

Original issue's description:
> Modifying TextBlobCacheTest to use SkRandomScalerContext
>
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/adcdca86ce425cf8c28bfad311cef028df756ee8

TBR=bungeman@google.com,bsalomon@google.com,joshualitt@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:

Review URL: https://codereview.chromium.org/1267623004

6 files changed, 62 insertions, 105 deletions

diff --git a/src/core/SkScalerContext.h b/src/core/SkScalerContext.h
index 6addf736fc..7fa1ef5fcd 100644
--- a/src/core/SkScalerContext.h
+++ b/src/core/SkScalerContext.h
@@ -301,8 +301,6 @@ protected:
     void forceOffGenerateImageFromPath() { fGenerateImageFromPath = false; }
 
 private:
-    friend class SkRandomScalerContext; // For debug purposes
-
     // never null
     SkAutoTUnref<SkTypeface> fTypeface;
 
diff --git a/src/fonts/SkRandomScalerContext.cpp b/src/fonts/SkRandomScalerContext.cpp
index 9a68e50376..2bfa289937 100644
--- a/src/fonts/SkRandomScalerContext.cpp
+++ b/src/fonts/SkRandomScalerContext.cpp
@@ -9,11 +9,10 @@
 #include "SkGlyph.h"
 #include "SkPath.h"
 #include "SkCanvas.h"
-#include "SkRasterizer.h"
 
 class SkRandomScalerContext : public SkScalerContext {
 public:
-    SkRandomScalerContext(SkRandomTypeface*, const SkDescriptor*, bool fFakeIt);
+    SkRandomScalerContext(SkRandomTypeface*, const SkDescriptor*);
     virtual ~SkRandomScalerContext();
 
 protected:
@@ -29,18 +28,15 @@ private:
     SkRandomTypeface*     fFace;
     SkScalerContext* fProxy;
     SkMatrix         fMatrix;
-    bool fFakeIt;
 };
 
 #define STD_SIZE    1
 
 #include "SkDescriptor.h"
 
-SkRandomScalerContext::SkRandomScalerContext(SkRandomTypeface* face, const SkDescriptor* desc,
-                                             bool fakeIt)
+SkRandomScalerContext::SkRandomScalerContext(SkRandomTypeface* face, const SkDescriptor* desc)
         : SkScalerContext(face, desc)
-        , fFace(face)
-        , fFakeIt(fakeIt) {
+        , fFace(face) {
     size_t  descSize = SkDescriptor::ComputeOverhead(1) + sizeof(SkScalerContext::Rec);
     SkAutoDescriptor ad(descSize);
     SkDescriptor*    newDesc = ad.getDesc();
@@ -88,10 +84,34 @@ void SkRandomScalerContext::generateAdvance(SkGlyph* glyph) {
 }
 
 void SkRandomScalerContext::generateMetrics(SkGlyph* glyph) {
+    fProxy->getAdvance(glyph);
+
+    SkVector advance;
+    fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
+                  SkFixedToScalar(glyph->fAdvanceY), &advance);
+    glyph->fAdvanceX = SkScalarToFixed(advance.fX);
+    glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+
+    SkPath path;
+    fProxy->getPath(*glyph, &path);
+    path.transform(fMatrix);
+
+    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();
+
     // 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() % 3) {
+    switch (glyph->getGlyphID() % 6) {
         case 0:
             format = SkMask::kLCD16_Format;
             break;
@@ -101,77 +121,28 @@ void SkRandomScalerContext::generateMetrics(SkGlyph* glyph) {
         case 2:
             format = SkMask::kARGB32_Format;
             break;
+        default:
+            // we will fiddle with these in generate image
+            format = (SkMask::Format)MASK_FORMAT_UNKNOWN;
     }
 
     glyph->fMaskFormat = format;
-    fProxy->getMetrics(glyph);
-
-    if (SkMask::kARGB32_Format == format) {
-        SkVector advance;
-        fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
-                      SkFixedToScalar(glyph->fAdvanceY), &advance);
-        glyph->fAdvanceX = SkScalarToFixed(advance.fX);
-        glyph->fAdvanceY = SkScalarToFixed(advance.fY);
-
-        SkPath path;
-        fProxy->getPath(*glyph, &path);
-        path.transform(fMatrix);
-
-        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() % 3) {
+    switch (glyph.getGlyphID() % 6) {
         case 0:
+        case 1:
+        case 2:
+            break;
+        case 3:
             format = SkMask::kLCD16_Format;
             break;
-        case 1:
+        case 4:
             format = SkMask::kA8_Format;
             break;
-        case 2:
+        case 5:
             format = SkMask::kARGB32_Format;
             break;
     }
@@ -179,28 +150,24 @@ void SkRandomScalerContext::generateImage(const SkGlyph& glyph) {
 
     // 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.concat(fMatrix);
-            canvas.drawPath(path, fFace->paint());
-        } else {
-            fProxy->forceGenerateImageFromPath();
-            fProxy->getImage(glyph);
-            fProxy->forceOffGenerateImageFromPath();
-        }
+    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.concat(fMatrix);
+        canvas.drawPath(path, fFace->paint());
     } else {
-        sk_bzero(glyph.fImage, glyph.computeImageSize());
+        this->forceGenerateImageFromPath();
+        fProxy->getImage(glyph);
+        this->forceOffGenerateImageFromPath();
     }
 }
 
@@ -229,11 +196,10 @@ void SkRandomScalerContext::generateFontMetrics(SkPaint::FontMetrics* metrics) {
 
 #include "SkTypefaceCache.h"
 
-SkRandomTypeface::SkRandomTypeface(SkTypeface* proxy, const SkPaint& paint, bool fakeIt)
+SkRandomTypeface::SkRandomTypeface(SkTypeface* proxy, const SkPaint& paint)
     : SkTypeface(proxy->fontStyle(), SkTypefaceCache::NewFontID(), false)
     , fProxy(SkRef(proxy))
-    , fPaint(paint)
-    , fFakeIt(fakeIt) {}
+    , fPaint(paint) {}
 
 SkRandomTypeface::~SkRandomTypeface() {
     fProxy->unref();
@@ -241,7 +207,7 @@ SkRandomTypeface::~SkRandomTypeface() {
 
 SkScalerContext* SkRandomTypeface::onCreateScalerContext(
                                             const SkDescriptor* desc) const {
-    return SkNEW_ARGS(SkRandomScalerContext, (const_cast<SkRandomTypeface*>(this), desc, fFakeIt));
+    return SkNEW_ARGS(SkRandomScalerContext, (const_cast<SkRandomTypeface*>(this), desc));
 }
 
 void SkRandomTypeface::onFilterRec(SkScalerContextRec* rec) const {
diff --git a/src/fonts/SkRandomScalerContext.h b/src/fonts/SkRandomScalerContext.h
index 24b203f05c..8ad22beff0 100644
--- a/src/fonts/SkRandomScalerContext.h
+++ b/src/fonts/SkRandomScalerContext.h
@@ -18,7 +18,7 @@
 
 class SkRandomTypeface : public SkTypeface {
 public:
-    SkRandomTypeface(SkTypeface* proxy, const SkPaint&, bool fakeit);
+    SkRandomTypeface(SkTypeface* proxy, const SkPaint&);
     virtual ~SkRandomTypeface();
 
     SkTypeface* proxy() const { return fProxy; }
@@ -49,7 +49,6 @@ protected:
 private:
     SkTypeface* fProxy;
     SkPaint     fPaint;
-    bool        fFakeIt;
 };
 
 #endif
diff --git a/src/gpu/GrAtlasTextContext.cpp b/src/gpu/GrAtlasTextContext.cpp
index f5976392cc..08fbf5887a 100644
--- a/src/gpu/GrAtlasTextContext.cpp
+++ b/src/gpu/GrAtlasTextContext.cpp
@@ -1678,10 +1678,8 @@ public:
                         }
                         glyph = blob->fGlyphs[glyphOffset];
                         SkASSERT(glyph);
-                        SkASSERT(id == glyph->fPackedID);
-                        // We want to be able to assert this but cannot for testing purposes.
-                        // once skbug:4143 has landed we can revist this assert
-                        //SkASSERT(glyph->fMaskFormat == this->maskFormat());
+                        SkASSERT(id == glyph->fPackedID &&
+                                 glyph->fMaskFormat == this->maskFormat());
 
                         if (!fFontCache->hasGlyph(glyph) &&
                             !strike->addGlyphToAtlas(batchTarget, glyph, scaler, skGlyph,
diff --git a/src/gpu/GrBatchAtlas.cpp b/src/gpu/GrBatchAtlas.cpp
index 59f2428cd9..c11c32b38d 100644
--- a/src/gpu/GrBatchAtlas.cpp
+++ b/src/gpu/GrBatchAtlas.cpp
@@ -42,10 +42,7 @@ public:
     // across atlas spills)
     int index() const { return fIndex; }
     int genID() const { return fGenID; }
-    GrBatchAtlas::AtlasID id() {
-        SkASSERT(GrBatchAtlas::kInvalidAtlasID != fID);
-        return fID;
-    }
+    GrBatchAtlas::AtlasID id() { return fID; }
 
     GrTexture* texture() const { return fTexture; }
 
diff --git a/src/gpu/GrBatchFontCache.cpp b/src/gpu/GrBatchFontCache.cpp
index 64d6bb1a1c..d6ffc507e7 100644
--- a/src/gpu/GrBatchFontCache.cpp
+++ b/src/gpu/GrBatchFontCache.cpp
@@ -226,7 +226,6 @@ bool GrBatchTextStrike::addGlyphToAtlas(GrBatchTarget* batchTarget, GrGlyph* gly
                                                glyph->width(), glyph->height(),
                                                storage.get(), &glyph->fAtlasLocation);
     if (success) {
-        SkASSERT(GrBatchAtlas::kInvalidAtlasID != glyph->fID);
         fAtlasedGlyphs++;
     }
     return success;