adding unit test for textblob cache / GrBatchAtlas

tests/TextBlobCacheTest.cpp

Index: tests/TextBlobCacheTest.cpp
diff --git a/tests/TextBlobCacheTest.cpp b/tests/TextBlobCacheTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b15af9083ab7dd36214a00c60ad2e877e04aaab1
--- /dev/null
+++ b/tests/TextBlobCacheTest.cpp
@@ -0,0 +1,123 @@
+/*
+ * 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"
+
+#ifdef SK_BUILD_FOR_WIN
+    #include "SkTypeface_win.h"
+#endif
+
+#include "Test.h"
+
+#if SK_SUPPORT_GPU
+#include "GrContextFactory.h"
+
+struct TextBlobWrapper {
+    explicit TextBlobWrapper(const SkTextBlob* blob) : fBlob(SkRef(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) {
+    for (int r = 0; r < redraw; r++) {
+        for (int i = 0; i < blobs.count(); i++) {
+            SkPaint paint;
+            canvas->drawTextBlob(blobs[i].fBlob.get(), 0, 0, paint);
+        }
+    }
+}
+
+// limit this just so we don't take too long to draw
+#define MAX_TOTAL_TEXT 4096
+#define MAX_CHAR 256
+#define MAX_FAMILIES 5
+
+// This test hammers the GPU textblobcache and font atlas
+DEF_TEST(TextBlobCache, reporter) {
+    SkAutoTDelete<GrContextFactory> grFactory(SkNEW(GrContextFactory));
+
+    // setup surface
+    uint32_t flags = 0;
+    SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
+
+    GrContext* ctx = grFactory->get(GrContextFactory::kNative_GLContextType);
+    SkImageInfo info = SkImageInfo::Make(1024, 768, 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(), MAX_FAMILIES);
+
+    // make a ton of text
+    uint16_t text[MAX_TOTAL_TEXT];
+    for (int i = 0; i < MAX_TOTAL_TEXT; i++) {
+        text[i] = i % MAX_CHAR;
+    }
+
+    // generate textblobs
+    SkTArray<TextBlobWrapper> blobs;
+    for (int i = 0; i < count; i++) {
+        SkPaint paint;
+        paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+        paint.setTextSize(256); // draw big glyphs to really stress the atlas
+
+        SkString familyName;

[bungeman-skia, 2015/07/17 19:49:10]

Doesn't look like you're using the family name here either.

+        fm->getFamilyName(i, &familyName);
+        SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
+        for (int j = 0; j < set->count(); ++j) {
+            SkFontStyle fs;

[bungeman-skia, 2015/07/17 19:49:09]

Still not using this? I don't see why you want to call set->getStyle at all?

+            set->getStyle(j, &fs, NULL);
+
+            SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
+
+            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));
+                        const SkTextBlobBuilder::RunBuffer& run = builder.allocRun(paint,
+                                                                                   MAX_TOTAL_TEXT,
+                                                                                   0, 0,
+                                                                                   NULL);
+                        memcpy(run.glyphs, text, MAX_TOTAL_TEXT * sizeof(uint16_t));
+                    }
+                }
+            }
+            SkNEW_APPEND_TO_TARRAY(&blobs, TextBlobWrapper, (builder.build()));
+        }
+    }
+
+    // test redraw
+    draw(canvas, 2, blobs);
+
+    // test draw after free
+    ctx->freeGpuResources();
+    draw(canvas, 1, blobs);
+
+    // test draw after abandon
+    ctx->abandonContext();
+    draw(canvas, 1, blobs);
+}
+#endif