static void TestPictureTypefaceSerialization(skiatest::Reporter* reporter) {
{
// Load typeface from file to test CreateFromFile with index.
SkString filename = GetResourcePath("/fonts/test.ttc");
sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFile(filename.c_str(), 1));
if (!typeface) {
INFOF(reporter, "Could not run fontstream test because test.ttc not found.");
} else {
serialize_and_compare_typeface(std::move(typeface), "A!", reporter);
}
}
{
// Load typeface as stream to create with axis settings.
SkAutoTDelete<SkStreamAsset> distortable(GetResourceAsStream("/fonts/Distortable.ttf"));
if (!distortable) {
INFOF(reporter, "Could not run fontstream test because Distortable.ttf not found.");
} else {
SkFixed axis = SK_FixedSqrt2;
sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(
new SkFontData(distortable.release(), 0, &axis, 1)));
if (!typeface) {
INFOF(reporter, "Could not run fontstream test because Distortable.ttf not created.");
} else {
serialize_and_compare_typeface(std::move(typeface), "abc", reporter);
}
}
}
}
bool FontPlatformData::isFixedPitch() const
{
#if ENABLE(GDI_FONTS_ON_WINDOWS)
// TEXTMETRICS have this. Set m_treatAsFixedPitch based off that.
HWndDC dc(0);
HGDIOBJ oldFont = SelectObject(dc, hfont());
// Yes, this looks backwards, but the fixed pitch bit is actually set if the font
// is *not* fixed pitch. Unbelievable but true.
TEXTMETRIC textMetric = { 0 };
if (!GetTextMetrics(dc, &textMetric)) {
if (ensureFontLoaded(hfont())) {
// Retry GetTextMetrics.
// FIXME: Handle gracefully the error if this call also fails.
// See http://crbug.com/6401.
if (!GetTextMetrics(dc, &textMetric))
WTF_LOG_ERROR("Unable to get the text metrics after second attempt");
}
}
bool treatAsFixedPitch = !(textMetric.tmPitchAndFamily & TMPF_FIXED_PITCH);
SelectObject(dc, oldFont);
return treatAsFixedPitch;
#else
return typeface() && typeface()->isFixedPitch();
#endif
}
void FontPlatformData::setupPaint(SkPaint* paint, GraphicsContext* context) const
{
const float ts = m_textSize >= 0 ? m_textSize : 12;
paint->setTextSize(SkFloatToScalar(m_textSize));
paint->setTypeface(typeface());
paint->setFakeBoldText(m_fakeBold);
paint->setTextSkewX(m_fakeItalic ? -SK_Scalar1 / 4 : 0);
paint->setSubpixelText(m_useSubpixelPositioning);
int textFlags = paintTextFlags();
// Only set painting flags when we're actually painting.
if (context && !context->couldUseLCDRenderedText()) {
textFlags &= ~SkPaint::kLCDRenderText_Flag;
// If we *just* clear our request for LCD, then GDI seems to
// sometimes give us AA text, and sometimes give us BW text. Since the
// original intent was LCD, we want to force AA (rather than BW), so we
// add a special bit to tell Skia to do its best to avoid the BW: by
// drawing LCD offscreen and downsampling that to AA.
textFlags |= SkPaint::kGenA8FromLCD_Flag;
}
static const uint32_t textFlagsMask = SkPaint::kAntiAlias_Flag |
SkPaint::kLCDRenderText_Flag |
SkPaint::kGenA8FromLCD_Flag;
SkASSERT(!(textFlags & ~textFlagsMask));
uint32_t flags = paint->getFlags();
flags &= ~textFlagsMask;
flags |= textFlags;
paint->setFlags(flags);
}
sk_sp<SkTypeface> emoji_typeface() {
if (!strcmp(sk_tool_utils::platform_os_emoji(), "CBDT")) {
return MakeResourceAsTypeface("/fonts/Funkster.ttf");
}
if (!strcmp(sk_tool_utils::platform_os_emoji(), "SBIX")) {
return SkTypeface::MakeFromName("Apple Color Emoji", SkFontStyle());
}
if (!strcmp(sk_tool_utils::platform_os_emoji(), "COLR")) {
sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
const char *colorEmojiFontName = "Segoe UI Emoji";
sk_sp<SkTypeface> typeface(fm->matchFamilyStyle(colorEmojiFontName, SkFontStyle()));
if (typeface) {
return typeface;
}
sk_sp<SkTypeface> fallback(fm->matchFamilyStyleCharacter(
colorEmojiFontName, SkFontStyle(), nullptr /* bcp47 */, 0 /* bcp47Count */,
0x1f4b0 /* character: 💰 */));
if (fallback) {
return fallback;
}
// If we don't have Segoe UI Emoji and can't find a fallback, try Segoe UI Symbol.
// Windows 7 does not have Segoe UI Emoji; Segoe UI Symbol has the (non - color) emoji.
return SkTypeface::MakeFromName("Segoe UI Symbol", SkFontStyle());
}
return nullptr;
}
static void TestPictureTypefaceSerialization(skiatest::Reporter* reporter) {
{
// Load typeface from file to test CreateFromFile with index.
auto data = GetResourceAsData("fonts/test.ttc");
auto typeface = SkTypeface::MakeFromStream(new SkMemoryStream(std::move(data)), 1);
if (!typeface) {
INFOF(reporter, "Could not run fontstream test because test.ttc not found.");
} else {
serialize_and_compare_typeface(std::move(typeface), "A!", reporter);
}
}
{
// Load typeface as stream to create with axis settings.
std::unique_ptr<SkStreamAsset> distortable(GetResourceAsStream("fonts/Distortable.ttf"));
if (!distortable) {
INFOF(reporter, "Could not run fontstream test because Distortable.ttf not found.");
} else {
SkFixed axis = SK_FixedSqrt2;
sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(
skstd::make_unique<SkFontData>(std::move(distortable), 0, &axis, 1)));
if (!typeface) {
INFOF(reporter, "Could not run fontstream test because Distortable.ttf not created.");
} else {
serialize_and_compare_typeface(std::move(typeface), "abc", reporter);
}
}
}
}
SkTypeface* SkFontMgr_Indirect::createTypefaceFromFontId(const SkFontIdentity& id) const {
if (id.fDataId == SkFontIdentity::kInvalidDataId) {
return nullptr;
}
SkAutoMutexAcquire ama(fDataCacheMutex);
SkAutoTUnref<SkTypeface> dataTypeface;
int dataTypefaceIndex = 0;
for (int i = 0; i < fDataCache.count(); ++i) {
const DataEntry& entry = fDataCache[i];
if (entry.fDataId == id.fDataId) {
if (entry.fTtcIndex == id.fTtcIndex &&
!entry.fTypeface->weak_expired() && entry.fTypeface->try_ref())
{
return entry.fTypeface;
}
if (dataTypeface.get() == nullptr &&
!entry.fTypeface->weak_expired() && entry.fTypeface->try_ref())
{
dataTypeface.reset(entry.fTypeface);
dataTypefaceIndex = entry.fTtcIndex;
}
}
if (entry.fTypeface->weak_expired()) {
fDataCache.removeShuffle(i);
--i;
}
}
// No exact match, but did find a data match.
if (dataTypeface.get() != nullptr) {
SkAutoTDelete<SkStreamAsset> stream(dataTypeface->openStream(nullptr));
if (stream.get() != nullptr) {
return fImpl->createFromStream(stream.release(), dataTypefaceIndex);
}
}
// No data match, request data and add entry.
SkAutoTDelete<SkStreamAsset> stream(fProxy->getData(id.fDataId));
if (stream.get() == nullptr) {
return nullptr;
}
SkAutoTUnref<SkTypeface> typeface(fImpl->createFromStream(stream.release(), id.fTtcIndex));
if (typeface.get() == nullptr) {
return nullptr;
}
DataEntry& newEntry = fDataCache.push_back();
typeface->weak_ref();
newEntry.fDataId = id.fDataId;
newEntry.fTtcIndex = id.fTtcIndex;
newEntry.fTypeface = typeface.get(); // weak reference passed to new entry.
return typeface.release();
}
bool FontPlatformData::operator==(const FontPlatformData& a) const {
// If either of the typeface pointers are null then we test for pointer
// equality. Otherwise, we call SkTypeface::Equal on the valid pointers.
bool typefacesEqual = false;
if (!typeface() || !a.typeface())
typefacesEqual = typeface() == a.typeface();
else
typefacesEqual = SkTypeface::Equal(typeface(), a.typeface());
return typefacesEqual && m_textSize == a.m_textSize &&
m_isHashTableDeletedValue == a.m_isHashTableDeletedValue &&
m_syntheticBold == a.m_syntheticBold &&
m_syntheticItalic == a.m_syntheticItalic
#if OS(LINUX) || OS(ANDROID)
&& m_style == a.m_style
#endif
&& m_orientation == a.m_orientation;
}
sk_sp<SkPDFFont> SkPDFFont::GetFontResource(SkPDFCanon* canon,
SkTypeface* face,
SkGlyphID glyphID) {
SkASSERT(canon);
SkASSERT(face); // All SkPDFDevice::internalDrawText ensures this.
const SkAdvancedTypefaceMetrics* fontMetrics = SkPDFFont::GetMetrics(face, canon);
SkASSERT(fontMetrics); // SkPDFDevice::internalDrawText ensures the typeface is good.
// GetMetrics only returns null to signify a bad typeface.
const SkAdvancedTypefaceMetrics& metrics = *fontMetrics;
SkAdvancedTypefaceMetrics::FontType type = SkPDFFont::FontType(metrics);
bool multibyte = SkPDFFont::IsMultiByte(type);
SkGlyphID subsetCode = multibyte ? 0 : first_nonzero_glyph_for_single_byte_encoding(glyphID);
uint64_t fontID = (static_cast<uint64_t>(SkTypeface::UniqueID(face)) << 16) | subsetCode;
if (sk_sp<SkPDFFont>* found = canon->fFontMap.find(fontID)) {
SkDEBUGCODE(SkPDFFont* foundFont = found->get());
SkASSERT(foundFont && multibyte == foundFont->multiByteGlyphs());
return *found;
}
sk_sp<SkTypeface> typeface(sk_ref_sp(face));
SkASSERT(typeface);
SkGlyphID lastGlyph = SkToU16(typeface->countGlyphs() - 1);
// should be caught by SkPDFDevice::internalDrawText
SkASSERT(glyphID <= lastGlyph);
SkGlyphID firstNonZeroGlyph;
if (multibyte) {
firstNonZeroGlyph = 1;
} else {
firstNonZeroGlyph = subsetCode;
lastGlyph = SkToU16(SkTMin<int>((int)lastGlyph, 254 + (int)subsetCode));
}
SkPDFFont::Info info = {std::move(typeface), firstNonZeroGlyph, lastGlyph, type};
sk_sp<SkPDFFont> font;
switch (type) {
case SkAdvancedTypefaceMetrics::kType1CID_Font:
case SkAdvancedTypefaceMetrics::kTrueType_Font:
SkASSERT(multibyte);
font = sk_make_sp<SkPDFType0Font>(std::move(info), metrics);
break;
case SkAdvancedTypefaceMetrics::kType1_Font:
SkASSERT(!multibyte);
font = sk_make_sp<SkPDFType1Font>(std::move(info), metrics, canon);
break;
default:
SkASSERT(!multibyte);
// Type3 is our fallback font.
font = sk_make_sp<SkPDFType3Font>(std::move(info), metrics);
break;
}
canon->fFontMap.set(fontID, font);
return font;
}
String FontPlatformData::fontFamilyName() const
{
#if ENABLE(GDI_FONTS_ON_WINDOWS)
HWndDC dc(0);
HGDIOBJ oldFont = static_cast<HFONT>(SelectObject(dc, hfont()));
WCHAR name[LF_FACESIZE];
unsigned resultLength = GetTextFace(dc, LF_FACESIZE, name);
if (resultLength > 0)
resultLength--; // ignore the null terminator
SelectObject(dc, oldFont);
return String(name, resultLength);
#else
// FIXME: This returns the requested name, perhaps a better solution would be to
// return the list of names provided by SkTypeface::createFamilyNameIterator.
ASSERT(typeface());
SkString familyName;
typeface()->getFamilyName(&familyName);
return String::fromUTF8(familyName.c_str());
#endif
}
SkTypeface* GetResourceAsTypeface(const char* resource) {
SkAutoTDelete<SkStreamAsset> stream(GetResourceAsStream(resource));
if (!stream) {
return NULL;
}
SkAutoTUnref<SkTypeface> typeface(SkTypeface::CreateFromStream(stream.detach()));
if (!typeface) {
SkDebugf("Resource %s not a valid font.\n", resource);
}
return typeface.detach();
}
sk_sp<SkTypeface> WebFontDecoder::decode(SharedBuffer* buffer) {
if (!buffer) {
setErrorString("Empty Buffer");
return nullptr;
}
// This is the largest web font size which we'll try to transcode.
// TODO(bashi): 30MB seems low. Update the limit if necessary.
static const size_t maxWebFontSize = 30 * 1024 * 1024; // 30 MB
if (buffer->size() > maxWebFontSize) {
setErrorString("Web font size more than 30MB");
return nullptr;
}
// Most web fonts are compressed, so the result can be much larger than
// the original.
ots::ExpandingMemoryStream output(buffer->size(), maxWebFontSize);
double start = currentTime();
BlinkOTSContext otsContext;
const char* data = buffer->data();
TRACE_EVENT_BEGIN0("blink", "DecodeFont");
bool ok = otsContext.Process(&output, reinterpret_cast<const uint8_t*>(data),
buffer->size());
TRACE_EVENT_END0("blink", "DecodeFont");
if (!ok) {
setErrorString(otsContext.getErrorString());
return nullptr;
}
const size_t decodedLength = output.Tell();
recordDecodeSpeedHistogram(data, buffer->size(), currentTime() - start,
decodedLength);
sk_sp<SkData> skData = SkData::MakeWithCopy(output.get(), decodedLength);
SkMemoryStream* stream = new SkMemoryStream(skData);
#if OS(WIN)
sk_sp<SkTypeface> typeface(
FontCache::fontCache()->fontManager()->createFromStream(stream));
#else
sk_sp<SkTypeface> typeface = SkTypeface::MakeFromStream(stream);
#endif
if (!typeface) {
setErrorString("Not a valid font data");
return nullptr;
}
m_decodedSize = decodedLength;
return typeface;
}
unsigned FontPlatformData::hash() const
{
unsigned h = SkTypeface::UniqueID(typeface());
h ^= 0x01010101 * ((static_cast<int>(m_isHashTableDeletedValue) << 3) | (static_cast<int>(m_orientation) << 2) | (static_cast<int>(m_syntheticBold) << 1) | static_cast<int>(m_syntheticItalic));
// This memcpy is to avoid a reinterpret_cast that breaks strict-aliasing
// rules. Memcpy is generally optimized enough so that performance doesn't
// matter here.
uint32_t textSizeBytes;
memcpy(&textSizeBytes, &m_textSize, sizeof(uint32_t));
h ^= textSizeBytes;
return h;
}
static SkPaint make_paint() {
SkPaint paint;
paint.setHinting(make_paint_hinting());
paint.setAntiAlias(make_bool());
paint.setDither(make_bool());
paint.setLinearText(make_bool());
paint.setSubpixelText(make_bool());
paint.setLCDRenderText(make_bool());
paint.setEmbeddedBitmapText(make_bool());
paint.setAutohinted(make_bool());
paint.setVerticalText(make_bool());
paint.setUnderlineText(make_bool());
paint.setStrikeThruText(make_bool());
paint.setFakeBoldText(make_bool());
paint.setDevKernText(make_bool());
paint.setFilterQuality(make_filter_quality());
paint.setStyle(make_paint_style());
paint.setColor(make_color());
paint.setStrokeWidth(make_scalar());
paint.setStrokeMiter(make_scalar());
paint.setStrokeCap(make_paint_cap());
paint.setStrokeJoin(make_paint_join());
paint.setColorFilter(make_color_filter());
paint.setXfermodeMode(make_xfermode());
paint.setPathEffect(make_path_effect());
paint.setMaskFilter(make_mask_filter());
if (false) {
// our validating buffer does not support typefaces yet, so skip this for now
SkAutoTUnref<SkTypeface> typeface(
SkTypeface::CreateFromName(make_font_name().c_str(), make_typeface_style()));
paint.setTypeface(typeface);
}
SkLayerRasterizer::Builder rasterizerBuilder;
SkPaint paintForRasterizer;
if (R(2) == 1) {
paintForRasterizer = make_paint();
}
rasterizerBuilder.addLayer(paintForRasterizer);
paint.setRasterizer(rasterizerBuilder.detach());
paint.setImageFilter(make_image_filter());
sk_sp<SkData> data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool()));
paint.setTextAlign(make_paint_align());
paint.setTextSize(make_scalar());
paint.setTextScaleX(make_scalar());
paint.setTextSkewX(make_scalar());
paint.setTextEncoding(make_paint_text_encoding());
return paint;
}
void FontPlatformData::setupPaint(SkPaint* paint,
GraphicsContext* context) const {
bool shouldSmoothFonts = true;
bool shouldAntialias = true;
bool useSubpixelText = true;
paint->setAntiAlias(shouldAntialias);
paint->setEmbeddedBitmapText(false);
const float ts = m_textSize >= 0 ? m_textSize : 12;
paint->setTextSize(SkFloatToScalar(ts));
paint->setTypeface(typeface());
paint->setFakeBoldText(m_syntheticBold);
paint->setTextSkewX(m_syntheticItalic ? -SK_Scalar1 / 4 : 0);
paint->setAutohinted(false); // freetype specific
paint->setLCDRenderText(shouldSmoothFonts);
paint->setSubpixelText(useSubpixelText);
paint->setHinting(SkPaint::kNo_Hinting);
}
void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
SkAutoTDelete<SkStreamAsset> distortable(GetResourceAsStream("/fonts/Distortable.ttf"));
if (!distortable) {
return;
}
const char* text = "abc";
const size_t textLen = strlen(text);
for (int j = 0; j < 2; ++j) {
for (int i = 0; i < 5; ++i) {
SkScalar x = SkIntToScalar(10);
SkScalar y = SkIntToScalar(20);
SkFixed axis = SkDoubleToFixed(0.5 + (5*j + i) * ((2.0 - 0.5) / (2 * 5)));
SkAutoTUnref<SkTypeface> typeface(SkTypeface::CreateFromFontData(
new SkFontData(distortable->duplicate(), 0, &axis, 1)));
paint.setTypeface(typeface);
SkAutoCanvasRestore acr(canvas, true);
canvas->translate(SkIntToScalar(30 + i * 100), SkIntToScalar(20));
rotate_about(canvas, SkIntToScalar(i * 5), x, y * 10);
{
SkPaint p;
p.setAntiAlias(true);
SkRect r;
r.set(x - SkIntToScalar(3), SkIntToScalar(15),
x - SkIntToScalar(1), SkIntToScalar(280));
canvas->drawRect(r, p);
}
for (int ps = 6; ps <= 22; ps++) {
paint.setTextSize(SkIntToScalar(ps));
canvas->drawText(text, textLen, x, y, paint);
y += paint.getFontMetrics(nullptr);
}
}
canvas->translate(0, SkIntToScalar(360));
paint.setSubpixelText(true);
}
}
sk_sp<SkTypeface> WhitelistDeserializeTypeface(SkStream* stream) {
SkFontDescriptor desc;
if (!SkFontDescriptor::Deserialize(stream, &desc)) {
return nullptr;
}
SkFontData* data = desc.detachFontData();
if (data) {
sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(data));
if (typeface) {
return typeface;
}
}
const char* familyName = desc.getFamilyName();
if (!strncmp(SUBNAME_PREFIX, familyName, sizeof(SUBNAME_PREFIX) - 1)) {
familyName += sizeof(SUBNAME_PREFIX) - 1;
}
return SkTypeface::MakeFromName(familyName, desc.getStyle());
}
sk_sp<SkTypeface> SkTypeface::MakeDeserialize(SkStream* stream) {
if (gDeserializeTypefaceDelegate) {
return (*gDeserializeTypefaceDelegate)(stream);
}
SkFontDescriptor desc;
if (!SkFontDescriptor::Deserialize(stream, &desc)) {
return nullptr;
}
SkFontData* data = desc.detachFontData();
if (data) {
sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(data));
if (typeface) {
return typeface;
}
}
return SkTypeface::MakeFromName(desc.getFamilyName(), desc.getStyle());
}
PassRefPtr<OpenTypeVerticalData> FontPlatformData::verticalData() const
{
return FontCache::fontCache()->getVerticalData(typeface()->uniqueID(), *this);
}
bool FontPlatformData::isFixedPitch() const
{
return typeface() && typeface()->isFixedPitch();
}
int main(int argc, char** argv) {
std::cerr << "Startup..." << std::endl;
try {
GameWindow window = GameWindow(640, 400, false);
InputManager* input_manager = window.get_input_manager();
window.use_context();
glClearColor(0.25f, 0.50f, 1.0f, 1.0f);
float r, g, b;
r = g = b = 0.0f;
Callback<void, KeyboardInputEvent> release_callback([&] (KeyboardInputEvent event) {
callback_function(".#.", event);
});
Callback<void, KeyboardInputEvent> down_callback([&] (KeyboardInputEvent event) {
callback_function("...", event);
});
Callback<void, KeyboardInputEvent> type_callback([&] (KeyboardInputEvent event) {
callback_function(".*.", event);
});
Callback<void, KeyboardInputEvent> press_callback([&] (KeyboardInputEvent event) {
if (event.key_code == SDLK_ESCAPE) {
release_callback.unregister_everywhere();
down_callback.unregister_everywhere();
type_callback.unregister_everywhere();
press_callback.unregister_everywhere();
}
else {
callback_function("._.", event);
}
});
{
Lifeline press_lifeline = input_manager->register_key_press_handler([&] (KeyboardInputEvent event) {
callback_function("!!!", event);
});
}
input_manager->register_key_release_handler(release_callback);
input_manager->register_key_down_handler(down_callback);
input_manager->register_key_type_handler(type_callback);
input_manager->register_key_press_handler(press_callback);
Typeface typeface("font.ttf");
TextFont font(typeface, 12);
Text text(&window, font, true);
text.move(100, 1000);
// text.set_text("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n\nThis_line_is_supposedly_very_long_and_should_not_render_properly! A B C");
text.set_text(load_file("UTF-8-test.txt"));
// for (int i = 0; i < 1000; i++) {
// text.resize(500, 400 + (i % 2));
// text.display();
// }
text.resize(800, 1000);
text.display();
TextFont big_font(typeface, 50);
Text cursor(&window, big_font, true);
cursor.move(100, 100);
cursor.resize(50, 60);
// Can ya tell what it is yet?
cursor.set_text({0xe2, 0x99, 0x98, 0x0});
// Lifeline mouse_lifeline = input_manager->register_mouse_handler(&mouse_callback_function);
Lifeline mouse_button_lifeline = input_manager->register_mouse_handler(filter({MOUSE_CLICKED}, &mouse_callback_function));
Lifeline cursor_lifeline = input_manager->register_mouse_handler(filter({MOUSE_MOVE}, [&] (MouseInputEvent event) {cursor.move(event.to.x, event.to.y);}));
while (window.check_close() == false) {
// Little basic colour change test.
r += 0.001;
g += 0.01;
b += 0.1;
if (r >= 1.0f) r = 0.0f;
if (g >= 1.0f) g = 0.0f;
if (b >= 1.0f) b = 0.0f;
glViewport(0, 0, window.get_size().first, window.get_size().second);
glClearColor(r, g, b, 0.8f);
glClear(GL_COLOR_BUFFER_BIT);
text.display();
cursor.display();
window.swap_buffers();
SDL_Delay(0);
GameWindow::update();
if (input_manager->is_key_down(SDLK_ESCAPE) && input_manager->is_key_down(SDLK_LSHIFT)) {
std::cerr << "Shift+Escape pressed!" << std::endl;
break;
}
}
release_callback.unregister_everywhere();
down_callback.unregister_everywhere();
type_callback.unregister_everywhere();
press_callback.unregister_everywhere();
}
catch (GameWindow::InitException e) {
std::cerr << e.what() << std::endl;
}
std::cerr << "Terminate" << std::endl;
return 0;
}
static void test_matchStyleCSS3(skiatest::Reporter* reporter) {
static const SkFontID invalidFontID = std::numeric_limits<SkFontID>::max();
static const SkFontStyle invalidFontStyle(101, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
class TestTypeface : public SkTypeface {
public:
TestTypeface(const SkFontStyle& fontStyle, SkFontID id) : SkTypeface(fontStyle, id, false) {}
protected:
SkStreamAsset* onOpenStream(int* ttcIndex) const override {
return nullptr;
}
SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override {
return nullptr;
}
void onFilterRec(SkScalerContextRec*) const override { }
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
PerGlyphInfo,
const uint32_t*, uint32_t) const override {
return nullptr;
}
void onGetFontDescriptor(SkFontDescriptor*, bool*) const override { }
virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
uint16_t glyphs[], int glyphCount) const override {
if (glyphs && glyphCount > 0) {
sk_bzero(glyphs, glyphCount * sizeof(glyphs[0]));
}
return 0;
}
int onCountGlyphs() const override {
return 0;
};
int onGetUPEM() const override {
return 0;
};
class EmptyLocalizedStrings : public SkTypeface::LocalizedStrings {
public:
bool next(SkTypeface::LocalizedString*) override {
return false;
}
};
void onGetFamilyName(SkString* familyName) const override {
familyName->reset();
}
SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override {
return new EmptyLocalizedStrings;
};
int onGetTableTags(SkFontTableTag tags[]) const override {
return 0;
}
size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const override {
return 0;
}
};
class TestFontStyleSet : public SkFontStyleSet {
public:
TestFontStyleSet(std::initializer_list<SkFontStyle> styles) : fStyles(styles) {}
int count() override {
return static_cast<int>(fStyles.size());
}
void getStyle(int index, SkFontStyle* style, SkString*) override {
if (style) {
*style = fStyles[index];
}
}
SkTypeface* createTypeface(int index) override {
if (index < 0 || this->count() <= index) {
return new TestTypeface(invalidFontStyle, invalidFontID);
}
return new TestTypeface(fStyles[index], index);
}
SkTypeface* matchStyle(const SkFontStyle& pattern) override {
return this->matchStyleCSS3(pattern);
}
private:
std::vector<SkFontStyle> fStyles;
};
SkFontStyle condensed_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kUpright_Slant);
SkFontStyle condensed_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kUpright_Slant);
SkFontStyle condensed_italic_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kItalic_Slant);
SkFontStyle condensed_italic_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kItalic_Slant);
SkFontStyle expanded_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kUpright_Slant);
SkFontStyle expanded_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kUpright_Slant);
SkFontStyle expanded_italic_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kItalic_Slant);
SkFontStyle expanded_italic_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kItalic_Slant);
SkFontStyle normal_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
SkFontStyle normal_normal_200(SkFontStyle::kExtraLight_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
SkFontStyle normal_normal_300(SkFontStyle::kLight_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
SkFontStyle normal_normal_400(SkFontStyle::kNormal_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
SkFontStyle normal_normal_500(SkFontStyle::kMedium_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
SkFontStyle normal_normal_600(SkFontStyle::kSemiBold_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
SkFontStyle normal_normal_700(SkFontStyle::kBold_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
SkFontStyle normal_normal_800(SkFontStyle::kExtraBold_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
SkFontStyle normal_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
struct StyleSetTest {
TestFontStyleSet styleSet;
struct Case {
SkFontStyle pattern;
SkFontStyle expectedResult;
};
std::vector<Case> cases;
} tests[] = {
{
{ condensed_normal_100,condensed_normal_900,condensed_italic_100,condensed_italic_900,
expanded_normal_100, expanded_normal_900, expanded_italic_100, expanded_italic_900
},
{
{ condensed_normal_100, condensed_normal_100 },
{ condensed_normal_900, condensed_normal_900 },
{ condensed_italic_100, condensed_italic_100 },
{ condensed_italic_900, condensed_italic_900 },
{ expanded_normal_100, expanded_normal_100 },
{ expanded_normal_900, expanded_normal_900 },
{ expanded_italic_100, expanded_italic_100 },
{ expanded_italic_900, expanded_italic_900 },
},
},
{
{ condensed_normal_100,condensed_italic_100,expanded_normal_100,expanded_italic_100 },
{
{ condensed_normal_100, condensed_normal_100 },
{ condensed_normal_900, condensed_normal_100 },
{ condensed_italic_100, condensed_italic_100 },
{ condensed_italic_900, condensed_italic_100 },
{ expanded_normal_100, expanded_normal_100 },
{ expanded_normal_900, expanded_normal_100 },
{ expanded_italic_100, expanded_italic_100 },
{ expanded_italic_900, expanded_italic_100 },
},
},
{
{ condensed_normal_900,condensed_italic_900,expanded_normal_900,expanded_italic_900 },
{
{ condensed_normal_100, condensed_normal_900 },
{ condensed_normal_900, condensed_normal_900 },
{ condensed_italic_100, condensed_italic_900 },
{ condensed_italic_900, condensed_italic_900 },
{ expanded_normal_100, expanded_normal_900 },
{ expanded_normal_900, expanded_normal_900 },
{ expanded_italic_100, expanded_italic_900 },
{ expanded_italic_900, expanded_italic_900 },
},
},
{
{ condensed_normal_100,condensed_normal_900,expanded_normal_100,expanded_normal_900 },
{
{ condensed_normal_100, condensed_normal_100 },
{ condensed_normal_900, condensed_normal_900 },
{ condensed_italic_100, condensed_normal_100 },
{ condensed_italic_900, condensed_normal_900 },
{ expanded_normal_100, expanded_normal_100 },
{ expanded_normal_900, expanded_normal_900 },
{ expanded_italic_100, expanded_normal_100 },
{ expanded_italic_900, expanded_normal_900 },
},
},
{
{ condensed_normal_100,expanded_normal_100 },
{
{ condensed_normal_100, condensed_normal_100 },
{ condensed_normal_900, condensed_normal_100 },
{ condensed_italic_100, condensed_normal_100 },
{ condensed_italic_900, condensed_normal_100 },
{ expanded_normal_100, expanded_normal_100 },
{ expanded_normal_900, expanded_normal_100 },
{ expanded_italic_100, expanded_normal_100 },
{ expanded_italic_900, expanded_normal_100 },
},
},
{
{ condensed_normal_900,expanded_normal_900 },
{
{ condensed_normal_100, condensed_normal_900 },
{ condensed_normal_900, condensed_normal_900 },
{ condensed_italic_100, condensed_normal_900 },
{ condensed_italic_900, condensed_normal_900 },
{ expanded_normal_100, expanded_normal_900 },
{ expanded_normal_900, expanded_normal_900 },
{ expanded_italic_100, expanded_normal_900 },
{ expanded_italic_900, expanded_normal_900 },
},
},
{
{ condensed_italic_100,condensed_italic_900,expanded_italic_100,expanded_italic_900 },
{
{ condensed_normal_100, condensed_italic_100 },
{ condensed_normal_900, condensed_italic_900 },
{ condensed_italic_100, condensed_italic_100 },
{ condensed_italic_900, condensed_italic_900 },
{ expanded_normal_100, expanded_italic_100 },
{ expanded_normal_900, expanded_italic_900 },
{ expanded_italic_100, expanded_italic_100 },
{ expanded_italic_900, expanded_italic_900 },
},
},
{
{ condensed_italic_100,expanded_italic_100 },
{
{ condensed_normal_100, condensed_italic_100 },
{ condensed_normal_900, condensed_italic_100 },
{ condensed_italic_100, condensed_italic_100 },
{ condensed_italic_900, condensed_italic_100 },
{ expanded_normal_100, expanded_italic_100 },
{ expanded_normal_900, expanded_italic_100 },
{ expanded_italic_100, expanded_italic_100 },
{ expanded_italic_900, expanded_italic_100 },
},
},
{
{ condensed_italic_900,expanded_italic_900 },
{
{ condensed_normal_100, condensed_italic_900 },
{ condensed_normal_900, condensed_italic_900 },
{ condensed_italic_100, condensed_italic_900 },
{ condensed_italic_900, condensed_italic_900 },
{ expanded_normal_100, expanded_italic_900 },
{ expanded_normal_900, expanded_italic_900 },
{ expanded_italic_100, expanded_italic_900 },
{ expanded_italic_900, expanded_italic_900 },
},
},
{
{ condensed_normal_100,condensed_normal_900,condensed_italic_100,condensed_italic_900 },
{
{ condensed_normal_100, condensed_normal_100 },
{ condensed_normal_900, condensed_normal_900 },
{ condensed_italic_100, condensed_italic_100 },
{ condensed_italic_900, condensed_italic_900 },
{ expanded_normal_100, condensed_normal_100 },
{ expanded_normal_900, condensed_normal_900 },
{ expanded_italic_100, condensed_italic_100 },
{ expanded_italic_900, condensed_italic_900 },
},
},
{
{ condensed_normal_100,condensed_italic_100 },
{
{ condensed_normal_100, condensed_normal_100 },
{ condensed_normal_900, condensed_normal_100 },
{ condensed_italic_100, condensed_italic_100 },
{ condensed_italic_900, condensed_italic_100 },
{ expanded_normal_100, condensed_normal_100 },
{ expanded_normal_900, condensed_normal_100 },
{ expanded_italic_100, condensed_italic_100 },
{ expanded_italic_900, condensed_italic_100 },
},
},
{
{ condensed_normal_900,condensed_italic_900 },
{
{ condensed_normal_100, condensed_normal_900 },
{ condensed_normal_900, condensed_normal_900 },
{ condensed_italic_100, condensed_italic_900 },
{ condensed_italic_900, condensed_italic_900 },
{ expanded_normal_100, condensed_normal_900 },
{ expanded_normal_900, condensed_normal_900 },
{ expanded_italic_100, condensed_italic_900 },
{ expanded_italic_900, condensed_italic_900 },
},
},
{
{ condensed_normal_100,condensed_normal_900 },
{
{ condensed_normal_100, condensed_normal_100 },
{ condensed_normal_900, condensed_normal_900 },
{ condensed_italic_100, condensed_normal_100 },
{ condensed_italic_900, condensed_normal_900 },
{ expanded_normal_100, condensed_normal_100 },
{ expanded_normal_900, condensed_normal_900 },
{ expanded_italic_100, condensed_normal_100 },
{ expanded_italic_900, condensed_normal_900 },
},
},
{
{ condensed_normal_100 },
{
{ condensed_normal_100, condensed_normal_100 },
{ condensed_normal_900, condensed_normal_100 },
{ condensed_italic_100, condensed_normal_100 },
{ condensed_italic_900, condensed_normal_100 },
{ expanded_normal_100, condensed_normal_100 },
{ expanded_normal_900, condensed_normal_100 },
{ expanded_italic_100, condensed_normal_100 },
{ expanded_italic_900, condensed_normal_100 },
},
},
{
{ condensed_normal_900 },
{
{ condensed_normal_100, condensed_normal_900 },
{ condensed_normal_900, condensed_normal_900 },
{ condensed_italic_100, condensed_normal_900 },
{ condensed_italic_900, condensed_normal_900 },
{ expanded_normal_100, condensed_normal_900 },
{ expanded_normal_900, condensed_normal_900 },
{ expanded_italic_100, condensed_normal_900 },
{ expanded_italic_900, condensed_normal_900 },
},
},
{
{ condensed_italic_100,condensed_italic_900 },
{
{ condensed_normal_100, condensed_italic_100 },
{ condensed_normal_900, condensed_italic_900 },
{ condensed_italic_100, condensed_italic_100 },
{ condensed_italic_900, condensed_italic_900 },
{ expanded_normal_100, condensed_italic_100 },
{ expanded_normal_900, condensed_italic_900 },
{ expanded_italic_100, condensed_italic_100 },
{ expanded_italic_900, condensed_italic_900 },
},
},
{
{ condensed_italic_100 },
{
{ condensed_normal_100, condensed_italic_100 },
{ condensed_normal_900, condensed_italic_100 },
{ condensed_italic_100, condensed_italic_100 },
{ condensed_italic_900, condensed_italic_100 },
{ expanded_normal_100, condensed_italic_100 },
{ expanded_normal_900, condensed_italic_100 },
{ expanded_italic_100, condensed_italic_100 },
{ expanded_italic_900, condensed_italic_100 },
},
},
{
{ condensed_italic_900 },
{
{ condensed_normal_100, condensed_italic_900 },
{ condensed_normal_900, condensed_italic_900 },
{ condensed_italic_100, condensed_italic_900 },
{ condensed_italic_900, condensed_italic_900 },
{ expanded_normal_100, condensed_italic_900 },
{ expanded_normal_900, condensed_italic_900 },
{ expanded_italic_100, condensed_italic_900 },
{ expanded_italic_900, condensed_italic_900 },
},
},
{
{ expanded_normal_100,expanded_normal_900,expanded_italic_100,expanded_italic_900 },
{
{ condensed_normal_100, expanded_normal_100 },
{ condensed_normal_900, expanded_normal_900 },
{ condensed_italic_100, expanded_italic_100 },
{ condensed_italic_900, expanded_italic_900 },
{ expanded_normal_100, expanded_normal_100 },
{ expanded_normal_900, expanded_normal_900 },
{ expanded_italic_100, expanded_italic_100 },
{ expanded_italic_900, expanded_italic_900 },
},
},
{
{ expanded_normal_100,expanded_italic_100 },
{
{ condensed_normal_100, expanded_normal_100 },
{ condensed_normal_900, expanded_normal_100 },
{ condensed_italic_100, expanded_italic_100 },
{ condensed_italic_900, expanded_italic_100 },
{ expanded_normal_100, expanded_normal_100 },
{ expanded_normal_900, expanded_normal_100 },
{ expanded_italic_100, expanded_italic_100 },
{ expanded_italic_900, expanded_italic_100 },
},
},
{
{ expanded_normal_900,expanded_italic_900 },
{
{ condensed_normal_100, expanded_normal_900 },
{ condensed_normal_900, expanded_normal_900 },
{ condensed_italic_100, expanded_italic_900 },
{ condensed_italic_900, expanded_italic_900 },
{ expanded_normal_100, expanded_normal_900 },
{ expanded_normal_900, expanded_normal_900 },
{ expanded_italic_100, expanded_italic_900 },
{ expanded_italic_900, expanded_italic_900 },
},
},
{
{ expanded_normal_100,expanded_normal_900 },
{
{ condensed_normal_100, expanded_normal_100 },
{ condensed_normal_900, expanded_normal_900 },
{ condensed_italic_100, expanded_normal_100 },
{ condensed_italic_900, expanded_normal_900 },
{ expanded_normal_100, expanded_normal_100 },
{ expanded_normal_900, expanded_normal_900 },
{ expanded_italic_100, expanded_normal_100 },
{ expanded_italic_900, expanded_normal_900 },
},
},
{
{ expanded_normal_100 },
{
{ condensed_normal_100, expanded_normal_100 },
{ condensed_normal_900, expanded_normal_100 },
{ condensed_italic_100, expanded_normal_100 },
{ condensed_italic_900, expanded_normal_100 },
{ expanded_normal_100, expanded_normal_100 },
{ expanded_normal_900, expanded_normal_100 },
{ expanded_italic_100, expanded_normal_100 },
{ expanded_italic_900, expanded_normal_100 },
},
},
{
{ expanded_normal_900 },
{
{ condensed_normal_100, expanded_normal_900 },
{ condensed_normal_900, expanded_normal_900 },
{ condensed_italic_100, expanded_normal_900 },
{ condensed_italic_900, expanded_normal_900 },
{ expanded_normal_100, expanded_normal_900 },
{ expanded_normal_900, expanded_normal_900 },
{ expanded_italic_100, expanded_normal_900 },
{ expanded_italic_900, expanded_normal_900 },
},
},
{
{ expanded_italic_100,expanded_italic_900 },
{
{ condensed_normal_100, expanded_italic_100 },
{ condensed_normal_900, expanded_italic_900 },
{ condensed_italic_100, expanded_italic_100 },
{ condensed_italic_900, expanded_italic_900 },
{ expanded_normal_100, expanded_italic_100 },
{ expanded_normal_900, expanded_italic_900 },
{ expanded_italic_100, expanded_italic_100 },
{ expanded_italic_900, expanded_italic_900 },
},
},
{
{ expanded_italic_100 },
{
{ condensed_normal_100, expanded_italic_100 },
{ condensed_normal_900, expanded_italic_100 },
{ condensed_italic_100, expanded_italic_100 },
{ condensed_italic_900, expanded_italic_100 },
{ expanded_normal_100, expanded_italic_100 },
{ expanded_normal_900, expanded_italic_100 },
{ expanded_italic_100, expanded_italic_100 },
{ expanded_italic_900, expanded_italic_100 },
},
},
{
{ expanded_italic_900 },
{
{ condensed_normal_100, expanded_italic_900 },
{ condensed_normal_900, expanded_italic_900 },
{ condensed_italic_100, expanded_italic_900 },
{ condensed_italic_900, expanded_italic_900 },
{ expanded_normal_100, expanded_italic_900 },
{ expanded_normal_900, expanded_italic_900 },
{ expanded_italic_100, expanded_italic_900 },
{ expanded_italic_900, expanded_italic_900 },
},
},
{
{ normal_normal_100, normal_normal_900 },
{
{ normal_normal_300, normal_normal_100 },
{ normal_normal_400, normal_normal_100 },
{ normal_normal_500, normal_normal_100 },
{ normal_normal_600, normal_normal_900 },
},
},
{
{ normal_normal_100, normal_normal_400, normal_normal_900 },
{
{ normal_normal_300, normal_normal_100 },
{ normal_normal_400, normal_normal_400 },
{ normal_normal_500, normal_normal_400 },
{ normal_normal_600, normal_normal_900 },
},
},
{
{ normal_normal_100, normal_normal_500, normal_normal_900 },
{
{ normal_normal_300, normal_normal_100 },
{ normal_normal_400, normal_normal_500 },
{ normal_normal_500, normal_normal_500 },
{ normal_normal_600, normal_normal_900 },
},
},
{
{ },
{
{ normal_normal_300, invalidFontStyle },
{ normal_normal_400, invalidFontStyle },
{ normal_normal_500, invalidFontStyle },
{ normal_normal_600, invalidFontStyle },
},
},
};
for (StyleSetTest& test : tests) {
for (const StyleSetTest::Case testCase : test.cases) {
SkAutoTUnref<SkTypeface> typeface(test.styleSet.matchStyle(testCase.pattern));
if (typeface) {
REPORTER_ASSERT(reporter, typeface->fontStyle() == testCase.expectedResult);
} else {
REPORTER_ASSERT(reporter, invalidFontStyle == testCase.expectedResult);
}
}
}
}
// This test hammers the GPU textblobcache and font atlas
static void text_blob_cache_inner(skiatest::Reporter* reporter, GrContext* context,
int maxTotalText, int maxGlyphID, int maxFamilies, bool normal,
bool stressTest) {
// setup surface
uint32_t flags = 0;
SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
// configure our context for maximum stressing of cache and atlas
if (stressTest) {
GrTest::SetupAlwaysEvictAtlas(context);
context->setTextBlobCacheLimit_ForTesting(0);
}
SkImageInfo info = SkImageInfo::Make(kWidth, kHeight, kN32_SkColorType, kPremul_SkAlphaType);
auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, 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, nullptr);
// 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(new 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,
nullptr);
memcpy(run.glyphs, text.get(), maxTotalText * sizeof(uint16_t));
}
}
}
blobs.emplace_back(builder.build());
}
}
// create surface where LCD is impossible
info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
SkSurfaceProps propsNoLCD(0, kUnknown_SkPixelGeometry);
auto surfaceNoLCD(canvas->makeSurface(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
context->freeGpuResources();
draw(canvas, 1, blobs);
context->freeGpuResources();
draw(canvasNoLCD, 1, blobs);
// test draw after abandon
context->abandonContext();
draw(canvas, 1, blobs);
}
PassRefPtr<OpenTypeVerticalData> FontPlatformData::verticalData() const
{
SkFontID id = typeface()->uniqueID();
return fontCache()->getVerticalData(id, *this);
}
SkFontID FontPlatformData::uniqueID() const
{
return typeface()->uniqueID();
}
static void test_systemfonts(skiatest::Reporter* reporter, bool verbose) {
static const SkFontTableTag nameTag = SkSetFourByteTag('n','a','m','e');
sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
int count = SkMin32(fm->countFamilies(), MAX_FAMILIES);
for (int i = 0; i < count; ++i) {
sk_sp<SkFontStyleSet> set(fm->createStyleSet(i));
for (int j = 0; j < set->count(); ++j) {
SkString sname;
SkFontStyle fs;
set->getStyle(j, &fs, &sname);
sk_sp<SkTypeface> typeface(set->createTypeface(j));
SkString familyName;
typeface->getFamilyName(&familyName);
if (verbose) {
SkDebugf("[%s]\n", familyName.c_str());
}
sk_sp<SkTypeface::LocalizedStrings> familyNamesIter(
typeface->createFamilyNameIterator());
SkTypeface::LocalizedString familyNameLocalized;
while (familyNamesIter->next(&familyNameLocalized)) {
if (verbose) {
SkDebugf("(%s) <%s>\n", familyNameLocalized.fString.c_str(),
familyNameLocalized.fLanguage.c_str());
}
}
size_t nameTableSize = typeface->getTableSize(nameTag);
if (0 == nameTableSize) {
continue;
}
SkAutoTMalloc<uint8_t> nameTableData(nameTableSize);
size_t copied = typeface->getTableData(nameTag, 0, nameTableSize, nameTableData.get());
if (copied != nameTableSize) {
continue;
}
SkOTTableName::Iterator::Record record;
SkOTTableName::Iterator familyNameIter(*((SkOTTableName*)nameTableData.get()),
SkOTTableName::Record::NameID::Predefined::FontFamilyName);
while (familyNameIter.next(record)) {
REPORTER_ASSERT_MESSAGE(reporter,
SkOTTableName::Record::NameID::Predefined::FontFamilyName == record.type,
"Requested family name, got something else."
);
if (verbose) {
SkDebugf("{%s} <%s>\n", record.name.c_str(), record.language.c_str());
}
}
SkOTTableName::Iterator styleNameIter(*((SkOTTableName*)nameTableData.get()),
SkOTTableName::Record::NameID::Predefined::FontSubfamilyName);
while (styleNameIter.next(record)) {
REPORTER_ASSERT_MESSAGE(reporter,
SkOTTableName::Record::NameID::Predefined::FontSubfamilyName == record.type,
"Requested subfamily name, got something else."
);
if (verbose) {
SkDebugf("{{%s}} <%s>\n", record.name.c_str(), record.language.c_str());
}
}
if (verbose) {
SkDebugf("\n");
}
}
}
}
