The Tor Browser: comparison gfx/skia/trunk/src/ports/SkFontHost

--1:000000000000
+:4bebb2344cf1
+/*
+* Copyright 2006 The Android Open Source Project
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+#include "SkAdvancedTypefaceMetrics.h"
+#include "SkBase64.h"
+#include "SkColorPriv.h"
+#include "SkData.h"
+#include "SkDescriptor.h"
+#include "SkFontDescriptor.h"
+#include "SkFontHost.h"
+#include "SkGlyph.h"
+#include "SkHRESULT.h"
+#include "SkMaskGamma.h"
+#include "SkOTTable_maxp.h"
+#include "SkOTTable_name.h"
+#include "SkOTUtils.h"
+#include "SkPath.h"
+#include "SkSFNTHeader.h"
+#include "SkStream.h"
+#include "SkString.h"
+#include "SkTemplates.h"
+#include "SkThread.h"
+#include "SkTypeface_win.h"
+#include "SkTypefaceCache.h"
+#include "SkUtils.h"
+#include "SkTypes.h"
+#include <tchar.h>
+#include <usp10.h>
+#include <objbase.h>
+static void (*gEnsureLOGFONTAccessibleProc)(const LOGFONT&);
+void SkTypeface_SetEnsureLOGFONTAccessibleProc(void (*proc)(const LOGFONT&)) {
+gEnsureLOGFONTAccessibleProc = proc;
+}
+static void call_ensure_accessible(const LOGFONT& lf) {
+if (gEnsureLOGFONTAccessibleProc) {
+gEnsureLOGFONTAccessibleProc(lf);
+}
+}
+///////////////////////////////////////////////////////////////////////////////
+// always packed xxRRGGBB
+typedef uint32_t SkGdiRGB;
+// define this in your Makefile or .gyp to enforce AA requests
+// which GDI ignores at small sizes. This flag guarantees AA
+// for rotated text, regardless of GDI's notions.
+//#define SK_ENFORCE_ROTATED_TEXT_AA_ON_WINDOWS
+static bool isLCD(const SkScalerContext::Rec& rec) {
+return SkMask::kLCD16_Format == rec.fMaskFormat ||
+SkMask::kLCD32_Format == rec.fMaskFormat;
+}
+static bool bothZero(SkScalar a, SkScalar b) {
+return 0 == a && 0 == b;
+}
+// returns false if there is any non-90-rotation or skew
+static bool isAxisAligned(const SkScalerContext::Rec& rec) {
+return 0 == rec.fPreSkewX &&
+(bothZero(rec.fPost2x2[0][1], rec.fPost2x2[1][0]) ||
+bothZero(rec.fPost2x2[0][0], rec.fPost2x2[1][1]));
+}
+static bool needToRenderWithSkia(const SkScalerContext::Rec& rec) {
+#ifdef SK_ENFORCE_ROTATED_TEXT_AA_ON_WINDOWS
+// What we really want to catch is when GDI will ignore the AA request and give
+// us BW instead. Smallish rotated text is one heuristic, so this code is just
+// an approximation. We shouldn't need to do this for larger sizes, but at those
+// sizes, the quality difference gets less and less between our general
+// scanconverter and GDI's.
+if (SkMask::kA8_Format == rec.fMaskFormat && !isAxisAligned(rec)) {
+return true;
+}
+#endif
+return rec.getHinting() == SkPaint::kNo_Hinting || rec.getHinting() == SkPaint::kSlight_Hinting;
+}
+using namespace skia_advanced_typeface_metrics_utils;
+static void tchar_to_skstring(const TCHAR t[], SkString* s) {
+#ifdef UNICODE
+size_t sSize = WideCharToMultiByte(CP_UTF8, 0, t, -1, NULL, 0, NULL, NULL);
+s->resize(sSize);
+WideCharToMultiByte(CP_UTF8, 0, t, -1, s->writable_str(), sSize, NULL, NULL);
+#else
+s->set(t);
+#endif
+}
+static void dcfontname_to_skstring(HDC deviceContext, const LOGFONT& lf, SkString* familyName) {
+int fontNameLen; //length of fontName in TCHARS.
+if (0 == (fontNameLen = GetTextFace(deviceContext, 0, NULL))) {
+call_ensure_accessible(lf);
+if (0 == (fontNameLen = GetTextFace(deviceContext, 0, NULL))) {
+fontNameLen = 0;
+}
+}
+SkAutoSTArray<LF_FULLFACESIZE, TCHAR> fontName(fontNameLen+1);
+if (0 == GetTextFace(deviceContext, fontNameLen, fontName.get())) {
+call_ensure_accessible(lf);
+if (0 == GetTextFace(deviceContext, fontNameLen, fontName.get())) {
+fontName[0] = 0;
+}
+}
+tchar_to_skstring(fontName.get(), familyName);
+}
+static void make_canonical(LOGFONT* lf) {
+lf->lfHeight = -64;
+lf->lfQuality = CLEARTYPE_QUALITY;//PROOF_QUALITY;
+lf->lfCharSet = DEFAULT_CHARSET;
+//    lf->lfClipPrecision = 64;
+}
+static SkTypeface::Style get_style(const LOGFONT& lf) {
+unsigned style = 0;
+if (lf.lfWeight >= FW_BOLD) {
+style |= SkTypeface::kBold;
+}
+if (lf.lfItalic) {
+style |= SkTypeface::kItalic;
+}
+return static_cast<SkTypeface::Style>(style);
+}
+static void setStyle(LOGFONT* lf, SkTypeface::Style style) {
+lf->lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;
+lf->lfItalic = ((style & SkTypeface::kItalic) != 0);
+}
+static inline FIXED SkFixedToFIXED(SkFixed x) {
+return *(FIXED*)(&x);
+}
+static inline SkFixed SkFIXEDToFixed(FIXED x) {
+return *(SkFixed*)(&x);
+}
+static inline FIXED SkScalarToFIXED(SkScalar x) {
+return SkFixedToFIXED(SkScalarToFixed(x));
+}
+static inline SkScalar SkFIXEDToScalar(FIXED x) {
+return SkFixedToScalar(SkFIXEDToFixed(x));
+}
+static unsigned calculateGlyphCount(HDC hdc, const LOGFONT& lf) {
+TEXTMETRIC textMetric;
+if (0 == GetTextMetrics(hdc, &textMetric)) {
+textMetric.tmPitchAndFamily = TMPF_VECTOR;
+call_ensure_accessible(lf);
+GetTextMetrics(hdc, &textMetric);
+}
+if (!(textMetric.tmPitchAndFamily & TMPF_VECTOR)) {
+return textMetric.tmLastChar;
+}
+// The 'maxp' table stores the number of glyphs at offset 4, in 2 bytes.
+uint16_t glyphs;
+if (GDI_ERROR != GetFontData(hdc, SkOTTableMaximumProfile::TAG, 4, &glyphs, sizeof(glyphs))) {
+return SkEndian_SwapBE16(glyphs);
+}
+// Binary search for glyph count.
+static const MAT2 mat2 = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};
+int32_t max = SK_MaxU16 + 1;
+int32_t min = 0;
+GLYPHMETRICS gm;
+while (min < max) {
+int32_t mid = min + ((max - min) / 2);
+if (GetGlyphOutlineW(hdc, mid, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0,
+NULL, &mat2) == GDI_ERROR) {
+max = mid;
+} else {
+min = mid + 1;
+}
+}
+SkASSERT(min == max);
+return min;
+}
+static unsigned calculateUPEM(HDC hdc, const LOGFONT& lf) {
+TEXTMETRIC textMetric;
+if (0 == GetTextMetrics(hdc, &textMetric)) {
+textMetric.tmPitchAndFamily = TMPF_VECTOR;
+call_ensure_accessible(lf);
+GetTextMetrics(hdc, &textMetric);
+}
+if (!(textMetric.tmPitchAndFamily & TMPF_VECTOR)) {
+return textMetric.tmMaxCharWidth;
+}
+OUTLINETEXTMETRIC otm;
+unsigned int otmRet = GetOutlineTextMetrics(hdc, sizeof(otm), &otm);
+if (0 == otmRet) {
+call_ensure_accessible(lf);
+otmRet = GetOutlineTextMetrics(hdc, sizeof(otm), &otm);
+}
+return (0 == otmRet) ? 0 : otm.otmEMSquare;
+}
+class LogFontTypeface : public SkTypeface {
+public:
+LogFontTypeface(SkTypeface::Style style, SkFontID fontID, const LOGFONT& lf, bool serializeAsStream = false) :
+SkTypeface(style, fontID, false), fLogFont(lf), fSerializeAsStream(serializeAsStream) {
+// If the font has cubic outlines, it will not be rendered with ClearType.
+HFONT font = CreateFontIndirect(&lf);
+HDC deviceContext = ::CreateCompatibleDC(NULL);
+HFONT savefont = (HFONT)SelectObject(deviceContext, font);
+TEXTMETRIC textMetric;
+if (0 == GetTextMetrics(deviceContext, &textMetric)) {
+call_ensure_accessible(lf);
+if (0 == GetTextMetrics(deviceContext, &textMetric)) {
+textMetric.tmPitchAndFamily = TMPF_TRUETYPE;
+}
+}
+if (deviceContext) {
+::SelectObject(deviceContext, savefont);
+::DeleteDC(deviceContext);
+}
+if (font) {
+::DeleteObject(font);
+}
+// The fixed pitch bit is set if the font is *not* fixed pitch.
+this->setIsFixedPitch((textMetric.tmPitchAndFamily & TMPF_FIXED_PITCH) == 0);
+// Used a logfont on a memory context, should never get a device font.
+// Therefore all TMPF_DEVICE will be PostScript (cubic) fonts.
+fCanBeLCD = !((textMetric.tmPitchAndFamily & TMPF_VECTOR) &&
+(textMetric.tmPitchAndFamily & TMPF_DEVICE));
+}
+LOGFONT fLogFont;
+bool fSerializeAsStream;
+bool fCanBeLCD;
+static LogFontTypeface* Create(const LOGFONT& lf) {
+SkTypeface::Style style = get_style(lf);
+SkFontID fontID = SkTypefaceCache::NewFontID();
+return new LogFontTypeface(style, fontID, lf);
+}
+static void EnsureAccessible(const SkTypeface* face) {
+call_ensure_accessible(static_cast<const LogFontTypeface*>(face)->fLogFont);
+}
+protected:
+virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE;
+virtual SkScalerContext* onCreateScalerContext(const SkDescriptor*) const SK_OVERRIDE;
+virtual void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE;
+virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
+SkAdvancedTypefaceMetrics::PerGlyphInfo,
+const uint32_t*, uint32_t) const SK_OVERRIDE;
+virtual void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE;
+virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
+uint16_t glyphs[], int glyphCount) const SK_OVERRIDE;
+virtual int onCountGlyphs() const SK_OVERRIDE;
+virtual int onGetUPEM() const SK_OVERRIDE;
+virtual SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE;
+virtual int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE;
+virtual size_t onGetTableData(SkFontTableTag, size_t offset,
+size_t length, void* data) const SK_OVERRIDE;
+};
+class FontMemResourceTypeface : public LogFontTypeface {
+public:
+/**
+*  Takes ownership of fontMemResource.
+*/
+FontMemResourceTypeface(SkTypeface::Style style, SkFontID fontID, const LOGFONT& lf, HANDLE fontMemResource) :
+LogFontTypeface(style, fontID, lf, true), fFontMemResource(fontMemResource) {
+}
+HANDLE fFontMemResource;
+/**
+*  The created FontMemResourceTypeface takes ownership of fontMemResource.
+*/
+static FontMemResourceTypeface* Create(const LOGFONT& lf, HANDLE fontMemResource) {
+SkTypeface::Style style = get_style(lf);
+SkFontID fontID = SkTypefaceCache::NewFontID();
+return new FontMemResourceTypeface(style, fontID, lf, fontMemResource);
+}
+protected:
+virtual void weak_dispose() const SK_OVERRIDE {
+RemoveFontMemResourceEx(fFontMemResource);
+//SkTypefaceCache::Remove(this);
+INHERITED::weak_dispose();
+}
+private:
+typedef LogFontTypeface INHERITED;
+};
+static const LOGFONT& get_default_font() {
+static LOGFONT gDefaultFont;
+return gDefaultFont;
+}
+static bool FindByLogFont(SkTypeface* face, SkTypeface::Style requestedStyle, void* ctx) {
+LogFontTypeface* lface = static_cast<LogFontTypeface*>(face);
+const LOGFONT* lf = reinterpret_cast<const LOGFONT*>(ctx);
+return lface &&
+get_style(lface->fLogFont) == requestedStyle &&
+!memcmp(&lface->fLogFont, lf, sizeof(LOGFONT));
+}
+/**
+*  This guy is public. It first searches the cache, and if a match is not found,
+*  it creates a new face.
+*/
+SkTypeface* SkCreateTypefaceFromLOGFONT(const LOGFONT& origLF) {
+LOGFONT lf = origLF;
+make_canonical(&lf);
+SkTypeface* face = SkTypefaceCache::FindByProcAndRef(FindByLogFont, &lf);
+if (NULL == face) {
+face = LogFontTypeface::Create(lf);
+SkTypefaceCache::Add(face, get_style(lf));
+}
+return face;
+}
+/**
+*  The created SkTypeface takes ownership of fontMemResource.
+*/
+SkTypeface* SkCreateFontMemResourceTypefaceFromLOGFONT(const LOGFONT& origLF, HANDLE fontMemResource) {
+LOGFONT lf = origLF;
+make_canonical(&lf);
+FontMemResourceTypeface* face = FontMemResourceTypeface::Create(lf, fontMemResource);
+SkTypefaceCache::Add(face, get_style(lf), false);
+return face;
+}
+/**
+*  This guy is public
+*/
+void SkLOGFONTFromTypeface(const SkTypeface* face, LOGFONT* lf) {
+if (NULL == face) {
+*lf = get_default_font();
+} else {
+*lf = static_cast<const LogFontTypeface*>(face)->fLogFont;
+}
+}
+// Construct Glyph to Unicode table.
+// Unicode code points that require conjugate pairs in utf16 are not
+// supported.
+// TODO(arthurhsu): Add support for conjugate pairs. It looks like that may
+// require parsing the TTF cmap table (platform 4, encoding 12) directly instead
+// of calling GetFontUnicodeRange().
+static void populate_glyph_to_unicode(HDC fontHdc, const unsigned glyphCount,
+SkTDArray<SkUnichar>* glyphToUnicode) {
+DWORD glyphSetBufferSize = GetFontUnicodeRanges(fontHdc, NULL);
+if (!glyphSetBufferSize) {
+return;
+}
+SkAutoTDeleteArray<BYTE> glyphSetBuffer(new BYTE[glyphSetBufferSize]);
+GLYPHSET* glyphSet =
+reinterpret_cast<LPGLYPHSET>(glyphSetBuffer.get());
+if (GetFontUnicodeRanges(fontHdc, glyphSet) != glyphSetBufferSize) {
+return;
+}
+glyphToUnicode->setCount(glyphCount);
+memset(glyphToUnicode->begin(), 0, glyphCount * sizeof(SkUnichar));
+for (DWORD i = 0; i < glyphSet->cRanges; ++i) {
+// There is no guarantee that within a Unicode range, the corresponding
+// glyph id in a font file are continuous. So, even if we have ranges,
+// we can't just use the first and last entry of the range to compute
+// result. We need to enumerate them one by one.
+int count = glyphSet->ranges[i].cGlyphs;
+SkAutoTArray<WCHAR> chars(count + 1);
+chars[count] = 0;  // termintate string
+SkAutoTArray<WORD> glyph(count);
+for (USHORT j = 0; j < count; ++j) {
+chars[j] = glyphSet->ranges[i].wcLow + j;
+}
+GetGlyphIndicesW(fontHdc, chars.get(), count, glyph.get(),
+GGI_MARK_NONEXISTING_GLYPHS);
+// If the glyph ID is valid, and the glyph is not mapped, then we will
+// fill in the char id into the vector. If the glyph is mapped already,
+// skip it.
+// TODO(arthurhsu): better improve this. e.g. Get all used char ids from
+// font cache, then generate this mapping table from there. It's
+// unlikely to have collisions since glyph reuse happens mostly for
+// different Unicode pages.
+for (USHORT j = 0; j < count; ++j) {
+if (glyph[j] != 0xffff && glyph[j] < glyphCount &&
+(*glyphToUnicode)[glyph[j]] == 0) {
+(*glyphToUnicode)[glyph[j]] = chars[j];
+}
+}
+}
+}
+//////////////////////////////////////////////////////////////////////////////////////
+static int alignTo32(int n) {
+return (n + 31) & ~31;
+}
+struct MyBitmapInfo : public BITMAPINFO {
+RGBQUAD fMoreSpaceForColors[1];
+};
+class HDCOffscreen {
+public:
+HDCOffscreen() {
+fFont = 0;
+fDC = 0;
+fBM = 0;
+fBits = NULL;
+fWidth = fHeight = 0;
+fIsBW = false;
+}
+~HDCOffscreen() {
+if (fDC) {
+DeleteDC(fDC);
+}
+if (fBM) {
+DeleteObject(fBM);
+}
+}
+void init(HFONT font, const XFORM& xform) {
+fFont = font;
+fXform = xform;
+}
+const void* draw(const SkGlyph&, bool isBW, size_t* srcRBPtr);
+private:
+HDC     fDC;
+HBITMAP fBM;
+HFONT   fFont;
+XFORM   fXform;
+void*   fBits;  // points into fBM
+int     fWidth;
+int     fHeight;
+bool    fIsBW;
+};
+const void* HDCOffscreen::draw(const SkGlyph& glyph, bool isBW,
+size_t* srcRBPtr) {
+// Can we share the scalercontext's fDDC, so we don't need to create
+// a separate fDC here?
+if (0 == fDC) {
+fDC = CreateCompatibleDC(0);
+if (0 == fDC) {
+return NULL;
+}
+SetGraphicsMode(fDC, GM_ADVANCED);
+SetBkMode(fDC, TRANSPARENT);
+SetTextAlign(fDC, TA_LEFT | TA_BASELINE);
+SelectObject(fDC, fFont);
+COLORREF color = 0x00FFFFFF;
+SkDEBUGCODE(COLORREF prev =) SetTextColor(fDC, color);
+SkASSERT(prev != CLR_INVALID);
+}
+if (fBM && (fIsBW != isBW || fWidth < glyph.fWidth || fHeight < glyph.fHeight)) {
+DeleteObject(fBM);
+fBM = 0;
+}
+fIsBW = isBW;
+fWidth = SkMax32(fWidth, glyph.fWidth);
+fHeight = SkMax32(fHeight, glyph.fHeight);
+int biWidth = isBW ? alignTo32(fWidth) : fWidth;
+if (0 == fBM) {
+MyBitmapInfo info;
+sk_bzero(&info, sizeof(info));
+if (isBW) {
+RGBQUAD blackQuad = { 0, 0, 0, 0 };
+RGBQUAD whiteQuad = { 0xFF, 0xFF, 0xFF, 0 };
+info.bmiColors[0] = blackQuad;
+info.bmiColors[1] = whiteQuad;
+}
+info.bmiHeader.biSize = sizeof(info.bmiHeader);
+info.bmiHeader.biWidth = biWidth;
+info.bmiHeader.biHeight = fHeight;
+info.bmiHeader.biPlanes = 1;
+info.bmiHeader.biBitCount = isBW ? 1 : 32;
+info.bmiHeader.biCompression = BI_RGB;
+if (isBW) {
+info.bmiHeader.biClrUsed = 2;
+}
+fBM = CreateDIBSection(fDC, &info, DIB_RGB_COLORS, &fBits, 0, 0);
+if (0 == fBM) {
+return NULL;
+}
+SelectObject(fDC, fBM);
+}
+// erase
+size_t srcRB = isBW ? (biWidth >> 3) : (fWidth << 2);
+size_t size = fHeight * srcRB;
+memset(fBits, 0, size);
+XFORM xform = fXform;
+xform.eDx = (float)-glyph.fLeft;
+xform.eDy = (float)-glyph.fTop;
+SetWorldTransform(fDC, &xform);
+uint16_t glyphID = glyph.getGlyphID();
+BOOL ret = ExtTextOutW(fDC, 0, 0, ETO_GLYPH_INDEX, NULL, reinterpret_cast<LPCWSTR>(&glyphID), 1, NULL);
+GdiFlush();
+if (0 == ret) {
+return NULL;
+}
+*srcRBPtr = srcRB;
+// offset to the start of the image
+return (const char*)fBits + (fHeight - glyph.fHeight) * srcRB;
+}
+//////////////////////////////////////////////////////////////////////////////
+#define BUFFERSIZE (1 << 13)
+class SkScalerContext_GDI : public SkScalerContext {
+public:
+SkScalerContext_GDI(SkTypeface*, const SkDescriptor* desc);
+virtual ~SkScalerContext_GDI();
+// Returns true if the constructor was able to complete all of its
+// initializations (which may include calling GDI).
+bool isValid() const;
+protected:
+virtual unsigned generateGlyphCount() SK_OVERRIDE;
+virtual uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE;
+virtual void generateAdvance(SkGlyph* glyph) SK_OVERRIDE;
+virtual void generateMetrics(SkGlyph* glyph) SK_OVERRIDE;
+virtual void generateImage(const SkGlyph& glyph) SK_OVERRIDE;
+virtual void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
+virtual void generateFontMetrics(SkPaint::FontMetrics* mX,
+SkPaint::FontMetrics* mY) SK_OVERRIDE;
+private:
+DWORD getGDIGlyphPath(const SkGlyph& glyph, UINT flags,
+SkAutoSTMalloc<BUFFERSIZE, uint8_t>* glyphbuf);
+HDCOffscreen fOffscreen;
+/** fGsA is the non-rotational part of total matrix without the text height scale.
+*  Used to find the magnitude of advances.
+*/
+MAT2         fGsA;
+/** The total matrix without the textSize. */
+MAT2         fMat22;
+/** Scales font to EM size. */
+MAT2         fHighResMat22;
+HDC          fDDC;
+HFONT        fSavefont;
+HFONT        fFont;
+SCRIPT_CACHE fSC;
+int          fGlyphCount;
+/** The total matrix which also removes EM scale. */
+SkMatrix     fHiResMatrix;
+/** fG_inv is the inverse of the rotational part of the total matrix.
+*  Used to set the direction of advances.
+*/
+SkMatrix     fG_inv;
+enum Type {
+kTrueType_Type, kBitmap_Type, kLine_Type
+} fType;
+TEXTMETRIC fTM;
+};
+static FIXED float2FIXED(float x) {
+return SkFixedToFIXED(SkFloatToFixed(x));
+}
+static BYTE compute_quality(const SkScalerContext::Rec& rec) {
+switch (rec.fMaskFormat) {
+case SkMask::kBW_Format:
+return NONANTIALIASED_QUALITY;
+case SkMask::kLCD16_Format:
+case SkMask::kLCD32_Format:
+return CLEARTYPE_QUALITY;
+default:
+if (rec.fFlags & SkScalerContext::kGenA8FromLCD_Flag) {
+return CLEARTYPE_QUALITY;
+} else {
+return ANTIALIASED_QUALITY;
+}
+}
+}
+SkScalerContext_GDI::SkScalerContext_GDI(SkTypeface* rawTypeface,
+const SkDescriptor* desc)
+: SkScalerContext(rawTypeface, desc)
+, fDDC(0)
+, fSavefont(0)
+, fFont(0)
+, fSC(0)
+, fGlyphCount(-1)
+{
+LogFontTypeface* typeface = reinterpret_cast<LogFontTypeface*>(rawTypeface);
+fDDC = ::CreateCompatibleDC(NULL);
+if (!fDDC) {
+return;
+}
+SetGraphicsMode(fDDC, GM_ADVANCED);
+SetBkMode(fDDC, TRANSPARENT);
+SkPoint h = SkPoint::Make(SK_Scalar1, 0);
+// A is the total matrix.
+SkMatrix A;
+fRec.getSingleMatrix(&A);
+A.mapPoints(&h, 1);
+// Find the Given's matrix [[c, -s],[s, c]] which rotates the baseline vector h
+// (where the baseline is mapped to) to the positive horizontal axis.
+const SkScalar& a = h.fX;
+const SkScalar& b = h.fY;
+SkScalar c, s;
+if (0 == b) {
+c = SkDoubleToScalar(_copysign(SK_Scalar1, a));
+s = 0;
+} else if (0 == a) {
+c = 0;
+s = SkDoubleToScalar(-_copysign(SK_Scalar1, b));
+} else if (SkScalarAbs(b) > SkScalarAbs(a)) {
+SkScalar t = a / b;
+SkScalar u = SkDoubleToScalar(_copysign(SkScalarSqrt(SK_Scalar1 + t*t), b));
+s = -1 / u;
+c = -s * t;
+} else {
+SkScalar t = b / a;
+SkScalar u = SkDoubleToScalar(_copysign(SkScalarSqrt(SK_Scalar1 + t*t), a));
+c = 1 / u;
+s = -c * t;
+}
+// G is the Given's Matrix for A (rotational matrix such that GA[0][1] == 0).
+SkMatrix G;
+G.setAll(c, -s, 0,
+s,  c, 0,
+0,  0, SkScalarToPersp(SK_Scalar1));
+// GA is the matrix A with rotation removed.
+SkMatrix GA(G);
+GA.preConcat(A);
+// realTextSize is the actual device size we want (as opposed to the size the user requested).
+// gdiTextSide is the size we request from GDI.
+// If the scale is negative, this means the matrix will do the flip anyway.
+SkScalar realTextSize = SkScalarAbs(GA.get(SkMatrix::kMScaleY));
+SkScalar gdiTextSize = SkScalarRoundToScalar(realTextSize);
+if (gdiTextSize == 0) {
+gdiTextSize = SK_Scalar1;
+}
+// When not hinting, remove only the gdiTextSize scale which will be applied by GDI.
+// When GDI hinting, remove the entire Y scale to prevent 'subpixel' metrics.
+SkScalar scale = (fRec.getHinting() == SkPaint::kNo_Hinting ||
+fRec.getHinting() == SkPaint::kSlight_Hinting)
+? SkScalarInvert(gdiTextSize)
+: SkScalarInvert(realTextSize);
+// sA is the total matrix A without the textSize (so GDI knows the text size separately).
+// When this matrix is used with GetGlyphOutline, no further processing is needed.
+SkMatrix sA(A);
+sA.preScale(scale, scale); //remove text size
+// GsA is the non-rotational part of A without the text height scale.
+// This is what is used to find the magnitude of advances.
+SkMatrix GsA(GA);
+GsA.preScale(scale, scale); //remove text size, G is rotational so reorders with the scale.
+fGsA.eM11 = SkScalarToFIXED(GsA.get(SkMatrix::kMScaleX));
+fGsA.eM12 = SkScalarToFIXED(-GsA.get(SkMatrix::kMSkewY)); // This should be ~0.
+fGsA.eM21 = SkScalarToFIXED(-GsA.get(SkMatrix::kMSkewX));
+fGsA.eM22 = SkScalarToFIXED(GsA.get(SkMatrix::kMScaleY));
+// fG_inv is G inverse, which is fairly simple since G is 2x2 rotational.
+fG_inv.setAll(G.get(SkMatrix::kMScaleX), -G.get(SkMatrix::kMSkewX), G.get(SkMatrix::kMTransX),
+-G.get(SkMatrix::kMSkewY), G.get(SkMatrix::kMScaleY), G.get(SkMatrix::kMTransY),
+G.get(SkMatrix::kMPersp0), G.get(SkMatrix::kMPersp1), G.get(SkMatrix::kMPersp2));
+LOGFONT lf = typeface->fLogFont;
+lf.lfHeight = -SkScalarTruncToInt(gdiTextSize);
+lf.lfQuality = compute_quality(fRec);
+fFont = CreateFontIndirect(&lf);
+if (!fFont) {
+return;
+}
+fSavefont = (HFONT)SelectObject(fDDC, fFont);
+if (0 == GetTextMetrics(fDDC, &fTM)) {
+call_ensure_accessible(lf);
+if (0 == GetTextMetrics(fDDC, &fTM)) {
+fTM.tmPitchAndFamily = TMPF_TRUETYPE;
+}
+}
+XFORM xform;
+if (fTM.tmPitchAndFamily & TMPF_VECTOR) {
+// Used a logfont on a memory context, should never get a device font.
+// Therefore all TMPF_DEVICE will be PostScript fonts.
+// If TMPF_VECTOR is set, one of TMPF_TRUETYPE or TMPF_DEVICE means that
+// we have an outline font. Otherwise we have a vector FON, which is
+// scalable, but not an outline font.
+// This was determined by testing with Type1 PFM/PFB and
+// OpenTypeCFF OTF, as well as looking at Wine bugs and sources.
+if (fTM.tmPitchAndFamily & (TMPF_TRUETYPE | TMPF_DEVICE)) {
+// Truetype or PostScript.
+fType = SkScalerContext_GDI::kTrueType_Type;
+} else {
+// Stroked FON.
+fType = SkScalerContext_GDI::kLine_Type;
+}
+// fPost2x2 is column-major, left handed (y down).
+// XFORM 2x2 is row-major, left handed (y down).
+xform.eM11 = SkScalarToFloat(sA.get(SkMatrix::kMScaleX));
+xform.eM12 = SkScalarToFloat(sA.get(SkMatrix::kMSkewY));
+xform.eM21 = SkScalarToFloat(sA.get(SkMatrix::kMSkewX));
+xform.eM22 = SkScalarToFloat(sA.get(SkMatrix::kMScaleY));
+xform.eDx = 0;
+xform.eDy = 0;
+// MAT2 is row major, right handed (y up).
+fMat22.eM11 = float2FIXED(xform.eM11);
+fMat22.eM12 = float2FIXED(-xform.eM12);
+fMat22.eM21 = float2FIXED(-xform.eM21);
+fMat22.eM22 = float2FIXED(xform.eM22);
+if (needToRenderWithSkia(fRec)) {
+this->forceGenerateImageFromPath();
+}
+// Create a hires matrix if we need linear metrics.
+if (this->isSubpixel()) {
+OUTLINETEXTMETRIC otm;
+UINT success = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
+if (0 == success) {
+call_ensure_accessible(lf);
+success = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
+}
+if (0 != success) {
+SkScalar upem = SkIntToScalar(otm.otmEMSquare);
+SkScalar gdiTextSizeToEMScale = upem / gdiTextSize;
+fHighResMat22.eM11 = float2FIXED(gdiTextSizeToEMScale);
+fHighResMat22.eM12 = float2FIXED(0);
+fHighResMat22.eM21 = float2FIXED(0);
+fHighResMat22.eM22 = float2FIXED(gdiTextSizeToEMScale);
+SkScalar removeEMScale = SkScalarInvert(upem);
+fHiResMatrix = A;
+fHiResMatrix.preScale(removeEMScale, removeEMScale);
+}
+}
+} else {
+// Assume bitmap
+fType = SkScalerContext_GDI::kBitmap_Type;
+xform.eM11 = 1.0f;
+xform.eM12 = 0.0f;
+xform.eM21 = 0.0f;
+xform.eM22 = 1.0f;
+xform.eDx = 0.0f;
+xform.eDy = 0.0f;
+// fPost2x2 is column-major, left handed (y down).
+// MAT2 is row major, right handed (y up).
+fMat22.eM11 = SkScalarToFIXED(fRec.fPost2x2[0][0]);
+fMat22.eM12 = SkScalarToFIXED(-fRec.fPost2x2[1][0]);
+fMat22.eM21 = SkScalarToFIXED(-fRec.fPost2x2[0][1]);
+fMat22.eM22 = SkScalarToFIXED(fRec.fPost2x2[1][1]);
+}
+fOffscreen.init(fFont, xform);
+}
+SkScalerContext_GDI::~SkScalerContext_GDI() {
+if (fDDC) {
+::SelectObject(fDDC, fSavefont);
+::DeleteDC(fDDC);
+}
+if (fFont) {
+::DeleteObject(fFont);
+}
+if (fSC) {
+::ScriptFreeCache(&fSC);
+}
+}
+bool SkScalerContext_GDI::isValid() const {
+return fDDC && fFont;
+}
+unsigned SkScalerContext_GDI::generateGlyphCount() {
+if (fGlyphCount < 0) {
+fGlyphCount = calculateGlyphCount(
+fDDC, static_cast<const LogFontTypeface*>(this->getTypeface())->fLogFont);
+}
+return fGlyphCount;
+}
+uint16_t SkScalerContext_GDI::generateCharToGlyph(SkUnichar utf32) {
+uint16_t index = 0;
+WCHAR utf16[2];
+// TODO(ctguil): Support characters that generate more than one glyph.
+if (SkUTF16_FromUnichar(utf32, (uint16_t*)utf16) == 1) {
+// Type1 fonts fail with uniscribe API. Use GetGlyphIndices for plane 0.
+/** Real documentation for GetGlyphIndiciesW:
+*
+*  When GGI_MARK_NONEXISTING_GLYPHS is not specified and a character does not map to a
+*  glyph, then the 'default character's glyph is returned instead. The 'default character'
+*  is available in fTM.tmDefaultChar. FON fonts have a default character, and there exists
+*  a usDefaultChar in the 'OS/2' table, version 2 and later. If there is no
+*  'default character' specified by the font, then often the first character found is used.
+*
+*  When GGI_MARK_NONEXISTING_GLYPHS is specified and a character does not map to a glyph,
+*  then the glyph 0xFFFF is used. In Windows XP and earlier, Bitmap/Vector FON usually use
+*  glyph 0x1F instead ('Terminal' appears to be special, returning 0xFFFF).
+*  Type1 PFM/PFB, TT, OT TT, OT CFF all appear to use 0xFFFF, even on XP.
+*/
+DWORD result = GetGlyphIndicesW(fDDC, utf16, 1, &index, GGI_MARK_NONEXISTING_GLYPHS);
+if (result == GDI_ERROR
+|| 0xFFFF == index
+|| (0x1F == index &&
+(fType == SkScalerContext_GDI::kBitmap_Type ||
+fType == SkScalerContext_GDI::kLine_Type)
+/*&& winVer < Vista */)
+)
+{
+index = 0;
+}
+} else {
+// Use uniscribe to detemine glyph index for non-BMP characters.
+static const int numWCHAR = 2;
+static const int maxItems = 2;
+// MSDN states that this can be NULL, but some things don't work then.
+SCRIPT_CONTROL sc = { 0 };
+// Add extra item to SCRIPT_ITEM to work around a bug (now documented).
+// https://bugzilla.mozilla.org/show_bug.cgi?id=366643
+SCRIPT_ITEM si[maxItems + 1];
+int numItems;
+HRZM(ScriptItemize(utf16, numWCHAR, maxItems, &sc, NULL, si, &numItems),
+"Could not itemize character.");
+// Sometimes ScriptShape cannot find a glyph for a non-BMP and returns 2 space glyphs.
+static const int maxGlyphs = 2;
+SCRIPT_VISATTR vsa[maxGlyphs];
+WORD outGlyphs[maxGlyphs];
+WORD logClust[numWCHAR];
+int numGlyphs;
+HRZM(ScriptShape(fDDC, &fSC, utf16, numWCHAR, maxGlyphs, &si[0].a,
+outGlyphs, logClust, vsa, &numGlyphs),
+"Could not shape character.");
+if (1 == numGlyphs) {
+index = outGlyphs[0];
+}
+}
+return index;
+}
+void SkScalerContext_GDI::generateAdvance(SkGlyph* glyph) {
+this->generateMetrics(glyph);
+}
+void SkScalerContext_GDI::generateMetrics(SkGlyph* glyph) {
+SkASSERT(fDDC);
+if (fType == SkScalerContext_GDI::kBitmap_Type || fType == SkScalerContext_GDI::kLine_Type) {
+SIZE size;
+WORD glyphs = glyph->getGlyphID(0);
+if (0 == GetTextExtentPointI(fDDC, &glyphs, 1, &size)) {
+glyph->fWidth = SkToS16(fTM.tmMaxCharWidth);
+} else {
+glyph->fWidth = SkToS16(size.cx);
+}
+glyph->fHeight = SkToS16(size.cy);
+glyph->fTop = SkToS16(-fTM.tmAscent);
+// Bitmap FON cannot underhang, but vector FON may.
+// There appears no means of determining underhang of vector FON.
+glyph->fLeft = SkToS16(0);
+glyph->fAdvanceX = SkIntToFixed(glyph->fWidth);
+glyph->fAdvanceY = 0;
+// Vector FON will transform nicely, but bitmap FON do not.
+if (fType == SkScalerContext_GDI::kLine_Type) {
+SkRect bounds = SkRect::MakeXYWH(glyph->fLeft, glyph->fTop,
+glyph->fWidth, glyph->fHeight);
+SkMatrix m;
+m.setAll(SkFIXEDToScalar(fMat22.eM11), -SkFIXEDToScalar(fMat22.eM21), 0,
+-SkFIXEDToScalar(fMat22.eM12), SkFIXEDToScalar(fMat22.eM22), 0,
+0,  0, SkScalarToPersp(SK_Scalar1));
+m.mapRect(&bounds);
+bounds.roundOut();
+glyph->fLeft = SkScalarTruncToInt(bounds.fLeft);
+glyph->fTop = SkScalarTruncToInt(bounds.fTop);
+glyph->fWidth = SkScalarTruncToInt(bounds.width());
+glyph->fHeight = SkScalarTruncToInt(bounds.height());
+}
+// Apply matrix to advance.
+glyph->fAdvanceY = SkFixedMul(-SkFIXEDToFixed(fMat22.eM12), glyph->fAdvanceX);
+glyph->fAdvanceX = SkFixedMul(SkFIXEDToFixed(fMat22.eM11), glyph->fAdvanceX);
+return;
+}
+UINT glyphId = glyph->getGlyphID(0);
+GLYPHMETRICS gm;
+sk_bzero(&gm, sizeof(gm));
+DWORD status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fMat22);
+if (GDI_ERROR == status) {
+LogFontTypeface::EnsureAccessible(this->getTypeface());
+status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fMat22);
+if (GDI_ERROR == status) {
+glyph->zeroMetrics();
+return;
+}
+}
+bool empty = false;
+// The black box is either the embedded bitmap size or the outline extent.
+// It is 1x1 if nothing is to be drawn, but will also be 1x1 if something very small
+// is to be drawn, like a '.'. We need to outset '.' but do not wish to outset ' '.
+if (1 == gm.gmBlackBoxX && 1 == gm.gmBlackBoxY) {
+// If GetGlyphOutline with GGO_NATIVE returns 0, we know there was no outline.
+DWORD bufferSize = GetGlyphOutlineW(fDDC, glyphId, GGO_NATIVE | GGO_GLYPH_INDEX, &gm, 0, NULL, &fMat22);
+empty = (0 == bufferSize);
+}
+glyph->fTop = SkToS16(-gm.gmptGlyphOrigin.y);
+glyph->fLeft = SkToS16(gm.gmptGlyphOrigin.x);
+if (empty) {
+glyph->fWidth = 0;
+glyph->fHeight = 0;
+} else {
+// Outset, since the image may bleed out of the black box.
+// For embedded bitmaps the black box should be exact.
+// For outlines we need to outset by 1 in all directions for bleed.
+// For ClearType we need to outset by 2 for bleed.
+glyph->fWidth = gm.gmBlackBoxX + 4;
+glyph->fHeight = gm.gmBlackBoxY + 4;
+glyph->fTop -= 2;
+glyph->fLeft -= 2;
+}
+glyph->fAdvanceX = SkIntToFixed(gm.gmCellIncX);
+glyph->fAdvanceY = SkIntToFixed(gm.gmCellIncY);
+glyph->fRsbDelta = 0;
+glyph->fLsbDelta = 0;
+if (this->isSubpixel()) {
+sk_bzero(&gm, sizeof(gm));
+status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fHighResMat22);
+if (GDI_ERROR != status) {
+SkPoint advance;
+fHiResMatrix.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
+glyph->fAdvanceX = SkScalarToFixed(advance.fX);
+glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+}
+} else if (!isAxisAligned(this->fRec)) {
+status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fGsA);
+if (GDI_ERROR != status) {
+SkPoint advance;
+fG_inv.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
+glyph->fAdvanceX = SkScalarToFixed(advance.fX);
+glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+}
+}
+}
+static const MAT2 gMat2Identity = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};
+void SkScalerContext_GDI::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {
+if (!(mx || my)) {
+return;
+}
+if (mx) {
+sk_bzero(mx, sizeof(*mx));
+}
+if (my) {
+sk_bzero(my, sizeof(*my));
+}
+SkASSERT(fDDC);
+#ifndef SK_GDI_ALWAYS_USE_TEXTMETRICS_FOR_FONT_METRICS
+if (fType == SkScalerContext_GDI::kBitmap_Type || fType == SkScalerContext_GDI::kLine_Type) {
+#endif
+if (mx) {
+mx->fTop = SkIntToScalar(-fTM.tmAscent);
+mx->fAscent = SkIntToScalar(-fTM.tmAscent);
+mx->fDescent = SkIntToScalar(fTM.tmDescent);
+mx->fBottom = SkIntToScalar(fTM.tmDescent);
+mx->fLeading = SkIntToScalar(fTM.tmExternalLeading);
+}
+if (my) {
+my->fTop = SkIntToScalar(-fTM.tmAscent);
+my->fAscent = SkIntToScalar(-fTM.tmAscent);
+my->fDescent = SkIntToScalar(fTM.tmDescent);
+my->fBottom = SkIntToScalar(fTM.tmDescent);
+my->fLeading = SkIntToScalar(fTM.tmExternalLeading);
+my->fAvgCharWidth = SkIntToScalar(fTM.tmAveCharWidth);
+my->fMaxCharWidth = SkIntToScalar(fTM.tmMaxCharWidth);
+my->fXMin = 0;
+my->fXMax = my->fMaxCharWidth;
+//my->fXHeight = 0;
+}
+#ifndef SK_GDI_ALWAYS_USE_TEXTMETRICS_FOR_FONT_METRICS
+return;
+}
+#endif
+OUTLINETEXTMETRIC otm;
+uint32_t ret = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
+if (0 == ret) {
+LogFontTypeface::EnsureAccessible(this->getTypeface());
+ret = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
+}
+if (0 == ret) {
+return;
+}
+if (mx) {
+mx->fTop = SkIntToScalar(-otm.otmrcFontBox.left);
+mx->fAscent = SkIntToScalar(-otm.otmAscent);
+mx->fDescent = SkIntToScalar(-otm.otmDescent);
+mx->fBottom = SkIntToScalar(otm.otmrcFontBox.right);
+mx->fLeading = SkIntToScalar(otm.otmLineGap);
+mx->fUnderlineThickness = SkIntToScalar(otm.otmsUnderscoreSize);
+mx->fUnderlinePosition = -SkIntToScalar(otm.otmsUnderscorePosition);
+mx->fFlags |= SkPaint::FontMetrics::kUnderlineThinknessIsValid_Flag;
+mx->fFlags |= SkPaint::FontMetrics::kUnderlinePositionIsValid_Flag;
+}
+if (my) {
+#ifndef SK_GDI_ALWAYS_USE_TEXTMETRICS_FOR_FONT_METRICS
+my->fTop = SkIntToScalar(-otm.otmrcFontBox.top);
+my->fAscent = SkIntToScalar(-otm.otmAscent);
+my->fDescent = SkIntToScalar(-otm.otmDescent);
+my->fBottom = SkIntToScalar(-otm.otmrcFontBox.bottom);
+my->fLeading = SkIntToScalar(otm.otmLineGap);
+my->fAvgCharWidth = SkIntToScalar(otm.otmTextMetrics.tmAveCharWidth);
+my->fMaxCharWidth = SkIntToScalar(otm.otmTextMetrics.tmMaxCharWidth);
+my->fXMin = SkIntToScalar(otm.otmrcFontBox.left);
+my->fXMax = SkIntToScalar(otm.otmrcFontBox.right);
+my->fUnderlineThickness = SkIntToScalar(otm.otmsUnderscoreSize);
+my->fUnderlinePosition = -SkIntToScalar(otm.otmsUnderscorePosition);
+my->fFlags |= SkPaint::FontMetrics::kUnderlineThinknessIsValid_Flag;
+my->fFlags |= SkPaint::FontMetrics::kUnderlinePositionIsValid_Flag;
+#endif
+my->fXHeight = SkIntToScalar(otm.otmsXHeight);
+GLYPHMETRICS gm;
+sk_bzero(&gm, sizeof(gm));
+DWORD len = GetGlyphOutlineW(fDDC, 'x', GGO_METRICS, &gm, 0, 0, &gMat2Identity);
+if (len != GDI_ERROR && gm.gmBlackBoxY > 0) {
+my->fXHeight = SkIntToScalar(gm.gmBlackBoxY);
+}
+}
+}
+////////////////////////////////////////////////////////////////////////////////////////
+#define SK_SHOW_TEXT_BLIT_COVERAGE 0
+static void build_power_table(uint8_t table[], float ee) {
+for (int i = 0; i < 256; i++) {
+float x = i / 255.f;
+x = sk_float_pow(x, ee);
+int xx = SkScalarRoundToInt(x * 255);
+table[i] = SkToU8(xx);
+}
+}
+/**
+*  This will invert the gamma applied by GDI (gray-scale antialiased), so we
+*  can get linear values.
+*
+*  GDI grayscale appears to use a hard-coded gamma of 2.3.
+*
+*  GDI grayscale appears to draw using the black and white rasterizer at four
+*  times the size and then downsamples to compute the coverage mask. As a
+*  result there are only seventeen total grays. This lack of fidelity means
+*  that shifting into other color spaces is imprecise.
+*/
+static const uint8_t* getInverseGammaTableGDI() {
+// Since build_power_table is idempotent, many threads can build gTableGdi
+// simultaneously.
+// Microsoft Specific:
+// Making gInited volatile provides read-aquire and write-release in vc++.
+// In VS2012, see compiler option /volatile:(ms|iso).
+// Replace with C++11 atomics when possible.
+static volatile bool gInited;
+static uint8_t gTableGdi[256];
+if (gInited) {
+// Need a L/L (read) barrier (full acquire not needed). If gInited is observed
+// true then gTableGdi is observable, but it must be requested.
+} else {
+build_power_table(gTableGdi, 2.3f);
+// Need a S/S (write) barrier (full release not needed) here so that this
+// write to gInited becomes observable after gTableGdi.
+gInited = true;
+}
+return gTableGdi;
+}
+/**
+*  This will invert the gamma applied by GDI ClearType, so we can get linear
+*  values.
+*
+*  GDI ClearType uses SPI_GETFONTSMOOTHINGCONTRAST / 1000 as the gamma value.
+*  If this value is not specified, the default is a gamma of 1.4.
+*/
+static const uint8_t* getInverseGammaTableClearType() {
+// We don't expect SPI_GETFONTSMOOTHINGCONTRAST to ever change, so building
+// gTableClearType with build_power_table is effectively idempotent.
+// Microsoft Specific:
+// Making gInited volatile provides read-aquire and write-release in vc++.
+// In VS2012, see compiler option /volatile:(ms|iso).
+// Replace with C++11 atomics when possible.
+static volatile bool gInited;
+static uint8_t gTableClearType[256];
+if (gInited) {
+// Need a L/L (read) barrier (acquire not needed). If gInited is observed
+// true then gTableClearType is observable, but it must be requested.
+} else {
+UINT level = 0;
+if (!SystemParametersInfo(SPI_GETFONTSMOOTHINGCONTRAST, 0, &level, 0) || !level) {
+// can't get the data, so use a default
+level = 1400;
+}
+build_power_table(gTableClearType, level / 1000.0f);
+// Need a S/S (write) barrier (release not needed) here so that this
+// write to gInited becomes observable after gTableClearType.
+gInited = true;
+}
+return gTableClearType;
+}
+#include "SkColorPriv.h"
+//Cannot assume that the input rgb is gray due to possible setting of kGenA8FromLCD_Flag.
+template<bool APPLY_PREBLEND>
+static inline uint8_t rgb_to_a8(SkGdiRGB rgb, const uint8_t* table8) {
+U8CPU r = (rgb >> 16) & 0xFF;
+U8CPU g = (rgb >>  8) & 0xFF;
+U8CPU b = (rgb >>  0) & 0xFF;
+return sk_apply_lut_if<APPLY_PREBLEND>(SkComputeLuminance(r, g, b), table8);
+}
+template<bool APPLY_PREBLEND>
+static inline uint16_t rgb_to_lcd16(SkGdiRGB rgb, const uint8_t* tableR,
+const uint8_t* tableG,
+const uint8_t* tableB) {
+U8CPU r = sk_apply_lut_if<APPLY_PREBLEND>((rgb >> 16) & 0xFF, tableR);
+U8CPU g = sk_apply_lut_if<APPLY_PREBLEND>((rgb >>  8) & 0xFF, tableG);
+U8CPU b = sk_apply_lut_if<APPLY_PREBLEND>((rgb >>  0) & 0xFF, tableB);
+#if SK_SHOW_TEXT_BLIT_COVERAGE
+r = SkMax32(r, 10); g = SkMax32(g, 10); b = SkMax32(b, 10);
+#endif
+return SkPack888ToRGB16(r, g, b);
+}
+template<bool APPLY_PREBLEND>
+static inline SkPMColor rgb_to_lcd32(SkGdiRGB rgb, const uint8_t* tableR,
+const uint8_t* tableG,
+const uint8_t* tableB) {
+U8CPU r = sk_apply_lut_if<APPLY_PREBLEND>((rgb >> 16) & 0xFF, tableR);
+U8CPU g = sk_apply_lut_if<APPLY_PREBLEND>((rgb >>  8) & 0xFF, tableG);
+U8CPU b = sk_apply_lut_if<APPLY_PREBLEND>((rgb >>  0) & 0xFF, tableB);
+#if SK_SHOW_TEXT_BLIT_COVERAGE
+r = SkMax32(r, 10); g = SkMax32(g, 10); b = SkMax32(b, 10);
+#endif
+return SkPackARGB32(0xFF, r, g, b);
+}
+// Is this GDI color neither black nor white? If so, we have to keep this
+// image as is, rather than smashing it down to a BW mask.
+//
+// returns int instead of bool, since we don't want/have to pay to convert
+// the zero/non-zero value into a bool
+static int is_not_black_or_white(SkGdiRGB c) {
+// same as (but faster than)
+//      c &= 0x00FFFFFF;
+//      return 0 == c || 0x00FFFFFF == c;
+return (c + (c & 1)) & 0x00FFFFFF;
+}
+static bool is_rgb_really_bw(const SkGdiRGB* src, int width, int height, size_t srcRB) {
+for (int y = 0; y < height; ++y) {
+for (int x = 0; x < width; ++x) {
+if (is_not_black_or_white(src[x])) {
+return false;
+}
+}
+src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
+}
+return true;
+}
+// gdi's bitmap is upside-down, so we reverse dst walking in Y
+// whenever we copy it into skia's buffer
+static void rgb_to_bw(const SkGdiRGB* SK_RESTRICT src, size_t srcRB,
+const SkGlyph& glyph) {
+const int width = glyph.fWidth;
+const size_t dstRB = (width + 7) >> 3;
+uint8_t* SK_RESTRICT dst = (uint8_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
+int byteCount = width >> 3;
+int bitCount = width & 7;
+// adjust srcRB to skip the values in our byteCount loop,
+// since we increment src locally there
+srcRB -= byteCount * 8 * sizeof(SkGdiRGB);
+for (int y = 0; y < glyph.fHeight; ++y) {
+if (byteCount > 0) {
+for (int i = 0; i < byteCount; ++i) {
+unsigned byte = 0;
+byte |= src[0] & (1 << 7);
+byte |= src[1] & (1 << 6);
+byte |= src[2] & (1 << 5);
+byte |= src[3] & (1 << 4);
+byte |= src[4] & (1 << 3);
+byte |= src[5] & (1 << 2);
+byte |= src[6] & (1 << 1);
+byte |= src[7] & (1 << 0);
+dst[i] = byte;
+src += 8;
+}
+}
+if (bitCount > 0) {
+unsigned byte = 0;
+unsigned mask = 0x80;
+for (int i = 0; i < bitCount; i++) {
+byte |= src[i] & mask;
+mask >>= 1;
+}
+dst[byteCount] = byte;
+}
+src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
+dst -= dstRB;
+}
+#if SK_SHOW_TEXT_BLIT_COVERAGE
+if (glyph.fWidth > 0 && glyph.fHeight > 0) {
+uint8_t* first = (uint8_t*)glyph.fImage;
+uint8_t* last = (uint8_t*)((char*)glyph.fImage + glyph.fHeight * dstRB - 1);
+*first |= 1 << 7;
+*last |= bitCount == 0 ? 1 : 1 << (8 - bitCount);
+}
+#endif
+}
+template<bool APPLY_PREBLEND>
+static void rgb_to_a8(const SkGdiRGB* SK_RESTRICT src, size_t srcRB,
+const SkGlyph& glyph, const uint8_t* table8) {
+const size_t dstRB = glyph.rowBytes();
+const int width = glyph.fWidth;
+uint8_t* SK_RESTRICT dst = (uint8_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
+for (int y = 0; y < glyph.fHeight; y++) {
+for (int i = 0; i < width; i++) {
+dst[i] = rgb_to_a8<APPLY_PREBLEND>(src[i], table8);
+#if SK_SHOW_TEXT_BLIT_COVERAGE
+dst[i] = SkMax32(dst[i], 10);
+#endif
+}
+src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
+dst -= dstRB;
+}
+}
+template<bool APPLY_PREBLEND>
+static void rgb_to_lcd16(const SkGdiRGB* SK_RESTRICT src, size_t srcRB, const SkGlyph& glyph,
+const uint8_t* tableR, const uint8_t* tableG, const uint8_t* tableB) {
+const size_t dstRB = glyph.rowBytes();
+const int width = glyph.fWidth;
+uint16_t* SK_RESTRICT dst = (uint16_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
+for (int y = 0; y < glyph.fHeight; y++) {
+for (int i = 0; i < width; i++) {
+dst[i] = rgb_to_lcd16<APPLY_PREBLEND>(src[i], tableR, tableG, tableB);
+}
+src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
+dst = (uint16_t*)((char*)dst - dstRB);
+}
+}
+template<bool APPLY_PREBLEND>
+static void rgb_to_lcd32(const SkGdiRGB* SK_RESTRICT src, size_t srcRB, const SkGlyph& glyph,
+const uint8_t* tableR, const uint8_t* tableG, const uint8_t* tableB) {
+const size_t dstRB = glyph.rowBytes();
+const int width = glyph.fWidth;
+uint32_t* SK_RESTRICT dst = (uint32_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
+for (int y = 0; y < glyph.fHeight; y++) {
+for (int i = 0; i < width; i++) {
+dst[i] = rgb_to_lcd32<APPLY_PREBLEND>(src[i], tableR, tableG, tableB);
+}
+src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
+dst = (uint32_t*)((char*)dst - dstRB);
+}
+}
+static inline unsigned clamp255(unsigned x) {
+SkASSERT(x <= 256);
+return x - (x >> 8);
+}
+void SkScalerContext_GDI::generateImage(const SkGlyph& glyph) {
+SkASSERT(fDDC);
+const bool isBW = SkMask::kBW_Format == fRec.fMaskFormat;
+const bool isAA = !isLCD(fRec);
+size_t srcRB;
+const void* bits = fOffscreen.draw(glyph, isBW, &srcRB);
+if (NULL == bits) {
+LogFontTypeface::EnsureAccessible(this->getTypeface());
+bits = fOffscreen.draw(glyph, isBW, &srcRB);
+if (NULL == bits) {
+sk_bzero(glyph.fImage, glyph.computeImageSize());
+return;
+}
+}
+if (!isBW) {
+const uint8_t* table;
+//The offscreen contains a GDI blit if isAA and kGenA8FromLCD_Flag is not set.
+//Otherwise the offscreen contains a ClearType blit.
+if (isAA && !(fRec.fFlags & SkScalerContext::kGenA8FromLCD_Flag)) {
+table = getInverseGammaTableGDI();
+} else {
+table = getInverseGammaTableClearType();
+}
+//Note that the following cannot really be integrated into the
+//pre-blend, since we may not be applying the pre-blend; when we aren't
+//applying the pre-blend it means that a filter wants linear anyway.
+//Other code may also be applying the pre-blend, so we'd need another
+//one with this and one without.
+SkGdiRGB* addr = (SkGdiRGB*)bits;
+for (int y = 0; y < glyph.fHeight; ++y) {
+for (int x = 0; x < glyph.fWidth; ++x) {
+int r = (addr[x] >> 16) & 0xFF;
+int g = (addr[x] >>  8) & 0xFF;
+int b = (addr[x] >>  0) & 0xFF;
+addr[x] = (table[r] << 16) | (table[g] << 8) | table[b];
+}
+addr = SkTAddOffset<SkGdiRGB>(addr, srcRB);
+}
+}
+int width = glyph.fWidth;
+size_t dstRB = glyph.rowBytes();
+if (isBW) {
+const uint8_t* src = (const uint8_t*)bits;
+uint8_t* dst = (uint8_t*)((char*)glyph.fImage + (glyph.fHeight - 1) * dstRB);
+for (int y = 0; y < glyph.fHeight; y++) {
+memcpy(dst, src, dstRB);
+src += srcRB;
+dst -= dstRB;
+}
+#if SK_SHOW_TEXT_BLIT_COVERAGE
+if (glyph.fWidth > 0 && glyph.fHeight > 0) {
+int bitCount = width & 7;
+uint8_t* first = (uint8_t*)glyph.fImage;
+uint8_t* last = (uint8_t*)((char*)glyph.fImage + glyph.fHeight * dstRB - 1);
+*first |= 1 << 7;
+*last |= bitCount == 0 ? 1 : 1 << (8 - bitCount);
+}
+#endif
+} else if (isAA) {
+// since the caller may require A8 for maskfilters, we can't check for BW
+// ... until we have the caller tell us that explicitly
+const SkGdiRGB* src = (const SkGdiRGB*)bits;
+if (fPreBlend.isApplicable()) {
+rgb_to_a8<true>(src, srcRB, glyph, fPreBlend.fG);
+} else {
+rgb_to_a8<false>(src, srcRB, glyph, fPreBlend.fG);
+}
+} else {    // LCD16
+const SkGdiRGB* src = (const SkGdiRGB*)bits;
+if (is_rgb_really_bw(src, width, glyph.fHeight, srcRB)) {
+rgb_to_bw(src, srcRB, glyph);
+((SkGlyph*)&glyph)->fMaskFormat = SkMask::kBW_Format;
+} else {
+if (SkMask::kLCD16_Format == glyph.fMaskFormat) {
+if (fPreBlend.isApplicable()) {
+rgb_to_lcd16<true>(src, srcRB, glyph,
+fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
+} else {
+rgb_to_lcd16<false>(src, srcRB, glyph,
+fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
+}
+} else {
+SkASSERT(SkMask::kLCD32_Format == glyph.fMaskFormat);
+if (fPreBlend.isApplicable()) {
+rgb_to_lcd32<true>(src, srcRB, glyph,
+fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
+} else {
+rgb_to_lcd32<false>(src, srcRB, glyph,
+fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
+}
+}
+}
+}
+}
+class GDIGlyphbufferPointIter {
+public:
+GDIGlyphbufferPointIter(const uint8_t* glyphbuf, DWORD total_size)
+: fHeaderIter(glyphbuf, total_size), fCurveIter(), fPointIter()
+{ }
+POINTFX const * next() {
+nextHeader:
+if (!fCurveIter.isSet()) {
+const TTPOLYGONHEADER* header = fHeaderIter.next();
+if (NULL == header) {
+return NULL;
+}
+fCurveIter.set(header);
+const TTPOLYCURVE* curve = fCurveIter.next();
+if (NULL == curve) {
+return NULL;
+}
+fPointIter.set(curve);
+return &header->pfxStart;
+}
+const POINTFX* nextPoint = fPointIter.next();
+if (NULL == nextPoint) {
+const TTPOLYCURVE* curve = fCurveIter.next();
+if (NULL == curve) {
+fCurveIter.set();
+goto nextHeader;
+} else {
+fPointIter.set(curve);
+}
+nextPoint = fPointIter.next();
+}
+return nextPoint;
+}
+WORD currentCurveType() {
+return fPointIter.fCurveType;
+}
+private:
+/** Iterates over all of the polygon headers in a glyphbuf. */
+class GDIPolygonHeaderIter {
+public:
+GDIPolygonHeaderIter(const uint8_t* glyphbuf, DWORD total_size)
+: fCurPolygon(reinterpret_cast<const TTPOLYGONHEADER*>(glyphbuf))
+, fEndPolygon(SkTAddOffset<const TTPOLYGONHEADER>(glyphbuf, total_size))
+{ }
+const TTPOLYGONHEADER* next() {
+if (fCurPolygon >= fEndPolygon) {
+return NULL;
+}
+const TTPOLYGONHEADER* thisPolygon = fCurPolygon;
+fCurPolygon = SkTAddOffset<const TTPOLYGONHEADER>(fCurPolygon, fCurPolygon->cb);
+return thisPolygon;
+}
+private:
+const TTPOLYGONHEADER* fCurPolygon;
+const TTPOLYGONHEADER* fEndPolygon;
+};
+/** Iterates over all of the polygon curves in a polygon header. */
+class GDIPolygonCurveIter {
+public:
+GDIPolygonCurveIter() : fCurCurve(NULL), fEndCurve(NULL) { }
+GDIPolygonCurveIter(const TTPOLYGONHEADER* curPolygon)
+: fCurCurve(SkTAddOffset<const TTPOLYCURVE>(curPolygon, sizeof(TTPOLYGONHEADER)))
+, fEndCurve(SkTAddOffset<const TTPOLYCURVE>(curPolygon, curPolygon->cb))
+{ }
+bool isSet() { return fCurCurve != NULL; }
+void set(const TTPOLYGONHEADER* curPolygon) {
+fCurCurve = SkTAddOffset<const TTPOLYCURVE>(curPolygon, sizeof(TTPOLYGONHEADER));
+fEndCurve = SkTAddOffset<const TTPOLYCURVE>(curPolygon, curPolygon->cb);
+}
+void set() {
+fCurCurve = NULL;
+fEndCurve = NULL;
+}
+const TTPOLYCURVE* next() {
+if (fCurCurve >= fEndCurve) {
+return NULL;
+}
+const TTPOLYCURVE* thisCurve = fCurCurve;
+fCurCurve = SkTAddOffset<const TTPOLYCURVE>(fCurCurve, size_of_TTPOLYCURVE(*fCurCurve));
+return thisCurve;
+}
+private:
+size_t size_of_TTPOLYCURVE(const TTPOLYCURVE& curve) {
+return 2*sizeof(WORD) + curve.cpfx*sizeof(POINTFX);
+}
+const TTPOLYCURVE* fCurCurve;
+const TTPOLYCURVE* fEndCurve;
+};
+/** Iterates over all of the polygon points in a polygon curve. */
+class GDIPolygonCurvePointIter {
+public:
+GDIPolygonCurvePointIter() : fCurveType(0), fCurPoint(NULL), fEndPoint(NULL) { }
+GDIPolygonCurvePointIter(const TTPOLYCURVE* curPolygon)
+: fCurveType(curPolygon->wType)
+, fCurPoint(&curPolygon->apfx[0])
+, fEndPoint(&curPolygon->apfx[curPolygon->cpfx])
+{ }
+bool isSet() { return fCurPoint != NULL; }
+void set(const TTPOLYCURVE* curPolygon) {
+fCurveType = curPolygon->wType;
+fCurPoint = &curPolygon->apfx[0];
+fEndPoint = &curPolygon->apfx[curPolygon->cpfx];
+}
+void set() {
+fCurPoint = NULL;
+fEndPoint = NULL;
+}
+const POINTFX* next() {
+if (fCurPoint >= fEndPoint) {
+return NULL;
+}
+const POINTFX* thisPoint = fCurPoint;
+++fCurPoint;
+return thisPoint;
+}
+WORD fCurveType;
+private:
+const POINTFX* fCurPoint;
+const POINTFX* fEndPoint;
+};
+GDIPolygonHeaderIter fHeaderIter;
+GDIPolygonCurveIter fCurveIter;
+GDIPolygonCurvePointIter fPointIter;
+};
+static void sk_path_from_gdi_path(SkPath* path, const uint8_t* glyphbuf, DWORD total_size) {
+const uint8_t* cur_glyph = glyphbuf;
+const uint8_t* end_glyph = glyphbuf + total_size;
+while (cur_glyph < end_glyph) {
+const TTPOLYGONHEADER* th = (TTPOLYGONHEADER*)cur_glyph;
+const uint8_t* end_poly = cur_glyph + th->cb;
+const uint8_t* cur_poly = cur_glyph + sizeof(TTPOLYGONHEADER);
+path->moveTo(SkFixedToScalar( SkFIXEDToFixed(th->pfxStart.x)),
+SkFixedToScalar(-SkFIXEDToFixed(th->pfxStart.y)));
+while (cur_poly < end_poly) {
+const TTPOLYCURVE* pc = (const TTPOLYCURVE*)cur_poly;
+if (pc->wType == TT_PRIM_LINE) {
+for (uint16_t i = 0; i < pc->cpfx; i++) {
+path->lineTo(SkFixedToScalar( SkFIXEDToFixed(pc->apfx[i].x)),
+SkFixedToScalar(-SkFIXEDToFixed(pc->apfx[i].y)));
+}
+}
+if (pc->wType == TT_PRIM_QSPLINE) {
+for (uint16_t u = 0; u < pc->cpfx - 1; u++) { // Walk through points in spline
+POINTFX pnt_b = pc->apfx[u];    // B is always the current point
+POINTFX pnt_c = pc->apfx[u+1];
+if (u < pc->cpfx - 2) {          // If not on last spline, compute C
+pnt_c.x = SkFixedToFIXED(SkFixedAve(SkFIXEDToFixed(pnt_b.x),
+SkFIXEDToFixed(pnt_c.x)));
+pnt_c.y = SkFixedToFIXED(SkFixedAve(SkFIXEDToFixed(pnt_b.y),
+SkFIXEDToFixed(pnt_c.y)));
+}
+path->quadTo(SkFixedToScalar( SkFIXEDToFixed(pnt_b.x)),
+SkFixedToScalar(-SkFIXEDToFixed(pnt_b.y)),
+SkFixedToScalar( SkFIXEDToFixed(pnt_c.x)),
+SkFixedToScalar(-SkFIXEDToFixed(pnt_c.y)));
+}
+}
+// Advance past this TTPOLYCURVE.
+cur_poly += sizeof(WORD) * 2 + sizeof(POINTFX) * pc->cpfx;
+}
+cur_glyph += th->cb;
+path->close();
+}
+}
+#define move_next_expected_hinted_point(iter, pElem) do {\
+pElem = iter.next(); \
+if (NULL == pElem) return false; \
+} while(0)
+// It is possible for the hinted and unhinted versions of the same path to have
+// a different number of points due to GDI's handling of flipped points.
+// If this is detected, this will return false.
+static bool sk_path_from_gdi_paths(SkPath* path, const uint8_t* glyphbuf, DWORD total_size,
+GDIGlyphbufferPointIter hintedYs) {
+const uint8_t* cur_glyph = glyphbuf;
+const uint8_t* end_glyph = glyphbuf + total_size;
+POINTFX const * hintedPoint;
+while (cur_glyph < end_glyph) {
+const TTPOLYGONHEADER* th = (TTPOLYGONHEADER*)cur_glyph;
+const uint8_t* end_poly = cur_glyph + th->cb;
+const uint8_t* cur_poly = cur_glyph + sizeof(TTPOLYGONHEADER);
+move_next_expected_hinted_point(hintedYs, hintedPoint);
+path->moveTo(SkFixedToScalar( SkFIXEDToFixed(th->pfxStart.x)),
+SkFixedToScalar(-SkFIXEDToFixed(hintedPoint->y)));
+while (cur_poly < end_poly) {
+const TTPOLYCURVE* pc = (const TTPOLYCURVE*)cur_poly;
+if (pc->wType == TT_PRIM_LINE) {
+for (uint16_t i = 0; i < pc->cpfx; i++) {
+move_next_expected_hinted_point(hintedYs, hintedPoint);
+path->lineTo(SkFixedToScalar( SkFIXEDToFixed(pc->apfx[i].x)),
+SkFixedToScalar(-SkFIXEDToFixed(hintedPoint->y)));
+}
+}
+if (pc->wType == TT_PRIM_QSPLINE) {
+POINTFX currentPoint = pc->apfx[0];
+move_next_expected_hinted_point(hintedYs, hintedPoint);
+// only take the hinted y if it wasn't flipped
+if (hintedYs.currentCurveType() == TT_PRIM_QSPLINE) {
+currentPoint.y = hintedPoint->y;
+}
+for (uint16_t u = 0; u < pc->cpfx - 1; u++) { // Walk through points in spline
+POINTFX pnt_b = currentPoint;//pc->apfx[u]; // B is always the current point
+POINTFX pnt_c = pc->apfx[u+1];
+move_next_expected_hinted_point(hintedYs, hintedPoint);
+// only take the hinted y if it wasn't flipped
+if (hintedYs.currentCurveType() == TT_PRIM_QSPLINE) {
+pnt_c.y = hintedPoint->y;
+}
+currentPoint.x = pnt_c.x;
+currentPoint.y = pnt_c.y;
+if (u < pc->cpfx - 2) {          // If not on last spline, compute C
+pnt_c.x = SkFixedToFIXED(SkFixedAve(SkFIXEDToFixed(pnt_b.x),
+SkFIXEDToFixed(pnt_c.x)));
+pnt_c.y = SkFixedToFIXED(SkFixedAve(SkFIXEDToFixed(pnt_b.y),
+SkFIXEDToFixed(pnt_c.y)));
+}
+path->quadTo(SkFixedToScalar( SkFIXEDToFixed(pnt_b.x)),
+SkFixedToScalar(-SkFIXEDToFixed(pnt_b.y)),
+SkFixedToScalar( SkFIXEDToFixed(pnt_c.x)),
+SkFixedToScalar(-SkFIXEDToFixed(pnt_c.y)));
+}
+}
+// Advance past this TTPOLYCURVE.
+cur_poly += sizeof(WORD) * 2 + sizeof(POINTFX) * pc->cpfx;
+}
+cur_glyph += th->cb;
+path->close();
+}
+return true;
+}
+DWORD SkScalerContext_GDI::getGDIGlyphPath(const SkGlyph& glyph, UINT flags,
+SkAutoSTMalloc<BUFFERSIZE, uint8_t>* glyphbuf)
+{
+GLYPHMETRICS gm;
+DWORD total_size = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, BUFFERSIZE, glyphbuf->get(), &fMat22);
+// Sometimes GetGlyphOutlineW returns a number larger than BUFFERSIZE even if BUFFERSIZE > 0.
+// It has been verified that this does not involve a buffer overrun.
+if (GDI_ERROR == total_size || total_size > BUFFERSIZE) {
+// GDI_ERROR because the BUFFERSIZE was too small, or because the data was not accessible.
+// When the data is not accessable GetGlyphOutlineW fails rather quickly,
+// so just try to get the size. If that fails then ensure the data is accessible.
+total_size = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, 0, NULL, &fMat22);
+if (GDI_ERROR == total_size) {
+LogFontTypeface::EnsureAccessible(this->getTypeface());
+total_size = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, 0, NULL, &fMat22);
+if (GDI_ERROR == total_size) {
+SkASSERT(false);
+return 0;
+}
+}
+glyphbuf->reset(total_size);
+DWORD ret = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, total_size, glyphbuf->get(), &fMat22);
+if (GDI_ERROR == ret) {
+LogFontTypeface::EnsureAccessible(this->getTypeface());
+ret = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, total_size, glyphbuf->get(), &fMat22);
+if (GDI_ERROR == ret) {
+SkASSERT(false);
+return 0;
+}
+}
+}
+return total_size;
+}
+void SkScalerContext_GDI::generatePath(const SkGlyph& glyph, SkPath* path) {
+SkASSERT(&glyph && path);
+SkASSERT(fDDC);
+path->reset();
+// Out of all the fonts on a typical Windows box,
+// 25% of glyphs require more than 2KB.
+// 1% of glyphs require more than 4KB.
+// 0.01% of glyphs require more than 8KB.
+// 8KB is less than 1% of the normal 1MB stack on Windows.
+// Note that some web fonts glyphs require more than 20KB.
+//static const DWORD BUFFERSIZE = (1 << 13);
+//GDI only uses hinted outlines when axis aligned.
+UINT format = GGO_NATIVE | GGO_GLYPH_INDEX;
+if (fRec.getHinting() == SkPaint::kNo_Hinting || fRec.getHinting() == SkPaint::kSlight_Hinting){
+format |= GGO_UNHINTED;
+}
+SkAutoSTMalloc<BUFFERSIZE, uint8_t> glyphbuf(BUFFERSIZE);
+DWORD total_size = getGDIGlyphPath(glyph, format, &glyphbuf);
+if (0 == total_size) {
+return;
+}
+if (fRec.getHinting() != SkPaint::kSlight_Hinting) {
+sk_path_from_gdi_path(path, glyphbuf, total_size);
+} else {
+//GDI only uses hinted outlines when axis aligned.
+UINT format = GGO_NATIVE | GGO_GLYPH_INDEX;
+SkAutoSTMalloc<BUFFERSIZE, uint8_t> hintedGlyphbuf(BUFFERSIZE);
+DWORD hinted_total_size = getGDIGlyphPath(glyph, format, &hintedGlyphbuf);
+if (0 == hinted_total_size) {
+return;
+}
+if (!sk_path_from_gdi_paths(path, glyphbuf, total_size,
+GDIGlyphbufferPointIter(hintedGlyphbuf, hinted_total_size)))
+{
+path->reset();
+sk_path_from_gdi_path(path, glyphbuf, total_size);
+}
+}
+}
+static void logfont_for_name(const char* familyName, LOGFONT* lf) {
+sk_bzero(lf, sizeof(LOGFONT));
+#ifdef UNICODE
+// Get the buffer size needed first.
+size_t str_len = ::MultiByteToWideChar(CP_UTF8, 0, familyName,
+-1, NULL, 0);
+// Allocate a buffer (str_len already has terminating null
+// accounted for).
+wchar_t *wideFamilyName = new wchar_t[str_len];
+// Now actually convert the string.
+::MultiByteToWideChar(CP_UTF8, 0, familyName, -1,
+wideFamilyName, str_len);
+::wcsncpy(lf->lfFaceName, wideFamilyName, LF_FACESIZE - 1);
+delete [] wideFamilyName;
+lf->lfFaceName[LF_FACESIZE-1] = L'\0';
+#else
+::strncpy(lf->lfFaceName, familyName, LF_FACESIZE - 1);
+lf->lfFaceName[LF_FACESIZE - 1] = '\0';
+#endif
+}
+void LogFontTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
+bool* isLocalStream) const {
+// Get the actual name of the typeface. The logfont may not know this.
+HFONT font = CreateFontIndirect(&fLogFont);
+HDC deviceContext = ::CreateCompatibleDC(NULL);
+HFONT savefont = (HFONT)SelectObject(deviceContext, font);
+SkString familyName;
+dcfontname_to_skstring(deviceContext, fLogFont, &familyName);
+if (deviceContext) {
+::SelectObject(deviceContext, savefont);
+::DeleteDC(deviceContext);
+}
+if (font) {
+::DeleteObject(font);
+}
+desc->setFamilyName(familyName.c_str());
+*isLocalStream = this->fSerializeAsStream;
+}
+static bool getWidthAdvance(HDC hdc, int gId, int16_t* advance) {
+// Initialize the MAT2 structure to the identify transformation matrix.
+static const MAT2 mat2 = {SkScalarToFIXED(1), SkScalarToFIXED(0),
+SkScalarToFIXED(0), SkScalarToFIXED(1)};
+int flags = GGO_METRICS | GGO_GLYPH_INDEX;
+GLYPHMETRICS gm;
+if (GDI_ERROR == GetGlyphOutline(hdc, gId, flags, &gm, 0, NULL, &mat2)) {
+return false;
+}
+SkASSERT(advance);
+*advance = gm.gmCellIncX;
+return true;
+}
+SkAdvancedTypefaceMetrics* LogFontTypeface::onGetAdvancedTypefaceMetrics(
+SkAdvancedTypefaceMetrics::PerGlyphInfo perGlyphInfo,
+const uint32_t* glyphIDs,
+uint32_t glyphIDsCount) const {
+LOGFONT lf = fLogFont;
+SkAdvancedTypefaceMetrics* info = NULL;
+HDC hdc = CreateCompatibleDC(NULL);
+HFONT font = CreateFontIndirect(&lf);
+HFONT savefont = (HFONT)SelectObject(hdc, font);
+HFONT designFont = NULL;
+const char stem_chars[] = {'i', 'I', '!', '1'};
+int16_t min_width;
+unsigned glyphCount;
+// To request design units, create a logical font whose height is specified
+// as unitsPerEm.
+OUTLINETEXTMETRIC otm;
+unsigned int otmRet = GetOutlineTextMetrics(hdc, sizeof(otm), &otm);
+if (0 == otmRet) {
+call_ensure_accessible(lf);
+otmRet = GetOutlineTextMetrics(hdc, sizeof(otm), &otm);
+}
+if (!otmRet || !GetTextFace(hdc, LF_FACESIZE, lf.lfFaceName)) {
+goto Error;
+}
+lf.lfHeight = -SkToS32(otm.otmEMSquare);
+designFont = CreateFontIndirect(&lf);
+SelectObject(hdc, designFont);
+if (!GetOutlineTextMetrics(hdc, sizeof(otm), &otm)) {
+goto Error;
+}
+glyphCount = calculateGlyphCount(hdc, fLogFont);
+info = new SkAdvancedTypefaceMetrics;
+info->fEmSize = otm.otmEMSquare;
+info->fMultiMaster = false;
+info->fLastGlyphID = SkToU16(glyphCount - 1);
+info->fStyle = 0;
+tchar_to_skstring(lf.lfFaceName, &info->fFontName);
+if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo) {
+populate_glyph_to_unicode(hdc, glyphCount, &(info->fGlyphToUnicode));
+}
+if (glyphCount > 0 &&
+(otm.otmTextMetrics.tmPitchAndFamily & TMPF_TRUETYPE)) {
+info->fType = SkAdvancedTypefaceMetrics::kTrueType_Font;
+} else {
+info->fType = SkAdvancedTypefaceMetrics::kOther_Font;
+info->fItalicAngle = 0;
+info->fAscent = 0;
+info->fDescent = 0;
+info->fStemV = 0;
+info->fCapHeight = 0;
+info->fBBox = SkIRect::MakeEmpty();
+goto ReturnInfo;
+}
+// If this bit is clear the font is a fixed pitch font.
+if (!(otm.otmTextMetrics.tmPitchAndFamily & TMPF_FIXED_PITCH)) {
+info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style;
+}
+if (otm.otmTextMetrics.tmItalic) {
+info->fStyle |= SkAdvancedTypefaceMetrics::kItalic_Style;
+}
+if (otm.otmTextMetrics.tmPitchAndFamily & FF_ROMAN) {
+info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style;
+} else if (otm.otmTextMetrics.tmPitchAndFamily & FF_SCRIPT) {
+info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style;
+}
+// The main italic angle of the font, in tenths of a degree counterclockwise
+// from vertical.
+info->fItalicAngle = otm.otmItalicAngle / 10;
+info->fAscent = SkToS16(otm.otmTextMetrics.tmAscent);
+info->fDescent = SkToS16(-otm.otmTextMetrics.tmDescent);
+// TODO(ctguil): Use alternate cap height calculation.
+// MSDN says otmsCapEmHeight is not support but it is returning a value on
+// my Win7 box.
+info->fCapHeight = otm.otmsCapEmHeight;
+info->fBBox =
+SkIRect::MakeLTRB(otm.otmrcFontBox.left, otm.otmrcFontBox.top,
+otm.otmrcFontBox.right, otm.otmrcFontBox.bottom);
+// Figure out a good guess for StemV - Min width of i, I, !, 1.
+// This probably isn't very good with an italic font.
+min_width = SHRT_MAX;
+info->fStemV = 0;
+for (size_t i = 0; i < SK_ARRAY_COUNT(stem_chars); i++) {
+ABC abcWidths;
+if (GetCharABCWidths(hdc, stem_chars[i], stem_chars[i], &abcWidths)) {
+int16_t width = abcWidths.abcB;
+if (width > 0 && width < min_width) {
+min_width = width;
+info->fStemV = min_width;
+}
+}
+}
+// If bit 1 is set, the font may not be embedded in a document.
+// If bit 1 is clear, the font can be embedded.
+// If bit 2 is set, the embedding is read-only.
+if (otm.otmfsType & 0x1) {
+info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
+} else if (perGlyphInfo &
+SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) {
+if (info->fStyle & SkAdvancedTypefaceMetrics::kFixedPitch_Style) {
+appendRange(&info->fGlyphWidths, 0);
+info->fGlyphWidths->fAdvance.append(1, &min_width);
+finishRange(info->fGlyphWidths.get(), 0,
+SkAdvancedTypefaceMetrics::WidthRange::kDefault);
+} else {
+info->fGlyphWidths.reset(
+getAdvanceData(hdc,
+glyphCount,
+glyphIDs,
+glyphIDsCount,
+&getWidthAdvance));
+}
+}
+Error:
+ReturnInfo:
+SelectObject(hdc, savefont);
+DeleteObject(designFont);
+DeleteObject(font);
+DeleteDC(hdc);
+return info;
+}
+//Dummy representation of a Base64 encoded GUID from create_unique_font_name.
+#define BASE64_GUID_ID "XXXXXXXXXXXXXXXXXXXXXXXX"
+//Length of GUID representation from create_id, including NULL terminator.
+#define BASE64_GUID_ID_LEN SK_ARRAY_COUNT(BASE64_GUID_ID)
+SK_COMPILE_ASSERT(BASE64_GUID_ID_LEN < LF_FACESIZE, GUID_longer_than_facesize);
+/**
+NameID 6 Postscript names cannot have the character '/'.
+It would be easier to hex encode the GUID, but that is 32 bytes,
+and many systems have issues with names longer than 28 bytes.
+The following need not be any standard base64 encoding.
+The encoded value is never decoded.
+*/
+static const char postscript_safe_base64_encode[] =
+"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+"abcdefghijklmnopqrstuvwxyz"
+"0123456789-_=";
+/**
+Formats a GUID into Base64 and places it into buffer.
+buffer should have space for at least BASE64_GUID_ID_LEN characters.
+The string will always be null terminated.
+XXXXXXXXXXXXXXXXXXXXXXXX0
+*/
+static void format_guid_b64(const GUID& guid, char* buffer, size_t bufferSize) {
+SkASSERT(bufferSize >= BASE64_GUID_ID_LEN);
+size_t written = SkBase64::Encode(&guid, sizeof(guid), buffer, postscript_safe_base64_encode);
+SkASSERT(written < LF_FACESIZE);
+buffer[written] = '\0';
+}
+/**
+Creates a Base64 encoded GUID and places it into buffer.
+buffer should have space for at least BASE64_GUID_ID_LEN characters.
+The string will always be null terminated.
+XXXXXXXXXXXXXXXXXXXXXXXX0
+*/
+static HRESULT create_unique_font_name(char* buffer, size_t bufferSize) {
+GUID guid = {};
+if (FAILED(CoCreateGuid(&guid))) {
+return E_UNEXPECTED;
+}
+format_guid_b64(guid, buffer, bufferSize);
+return S_OK;
+}
+/**
+Introduces a font to GDI. On failure will return NULL. The returned handle
+should eventually be passed to RemoveFontMemResourceEx.
+*/
+static HANDLE activate_font(SkData* fontData) {
+DWORD numFonts = 0;
+//AddFontMemResourceEx just copies the data, but does not specify const.
+HANDLE fontHandle = AddFontMemResourceEx(const_cast<void*>(fontData->data()),
+static_cast<DWORD>(fontData->size()),
+0,
+&numFonts);
+if (fontHandle != NULL && numFonts < 1) {
+RemoveFontMemResourceEx(fontHandle);
+return NULL;
+}
+return fontHandle;
+}
+static SkTypeface* create_from_stream(SkStream* stream) {
+// Create a unique and unpredictable font name.
+// Avoids collisions and access from CSS.
+char familyName[BASE64_GUID_ID_LEN];
+const int familyNameSize = SK_ARRAY_COUNT(familyName);
+if (FAILED(create_unique_font_name(familyName, familyNameSize))) {
+return NULL;
+}
+// Change the name of the font.
+SkAutoTUnref<SkData> rewrittenFontData(SkOTUtils::RenameFont(stream, familyName, familyNameSize-1));
+if (NULL == rewrittenFontData.get()) {
+return NULL;
+}
+// Register the font with GDI.
+HANDLE fontReference = activate_font(rewrittenFontData.get());
+if (NULL == fontReference) {
+return NULL;
+}
+// Create the typeface.
+LOGFONT lf;
+logfont_for_name(familyName, &lf);
+return SkCreateFontMemResourceTypefaceFromLOGFONT(lf, fontReference);
+}
+SkStream* LogFontTypeface::onOpenStream(int* ttcIndex) const {
+*ttcIndex = 0;
+const DWORD kTTCTag =
+SkEndian_SwapBE32(SkSetFourByteTag('t', 't', 'c', 'f'));
+LOGFONT lf = fLogFont;
+HDC hdc = ::CreateCompatibleDC(NULL);
+HFONT font = CreateFontIndirect(&lf);
+HFONT savefont = (HFONT)SelectObject(hdc, font);
+SkMemoryStream* stream = NULL;
+DWORD tables[2] = {kTTCTag, 0};
+for (int i = 0; i < SK_ARRAY_COUNT(tables); i++) {
+DWORD bufferSize = GetFontData(hdc, tables[i], 0, NULL, 0);
+if (bufferSize == GDI_ERROR) {
+call_ensure_accessible(lf);
+bufferSize = GetFontData(hdc, tables[i], 0, NULL, 0);
+}
+if (bufferSize != GDI_ERROR) {
+stream = new SkMemoryStream(bufferSize);
+if (GetFontData(hdc, tables[i], 0, (void*)stream->getMemoryBase(), bufferSize)) {
+break;
+} else {
+delete stream;
+stream = NULL;
+}
+}
+}
+SelectObject(hdc, savefont);
+DeleteObject(font);
+DeleteDC(hdc);
+return stream;
+}
+static void bmpCharsToGlyphs(HDC hdc, const WCHAR* bmpChars, int count, uint16_t* glyphs,
+bool Ox1FHack)
+{
+DWORD result = GetGlyphIndicesW(hdc, bmpChars, count, glyphs, GGI_MARK_NONEXISTING_GLYPHS);
+if (GDI_ERROR == result) {
+for (int i = 0; i < count; ++i) {
+glyphs[i] = 0;
+}
+return;
+}
+if (Ox1FHack) {
+for (int i = 0; i < count; ++i) {
+if (0xFFFF == glyphs[i] || 0x1F == glyphs[i]) {
+glyphs[i] = 0;
+}
+}
+} else {
+for (int i = 0; i < count; ++i) {
+if (0xFFFF == glyphs[i]){
+glyphs[i] = 0;
+}
+}
+}
+}
+static uint16_t nonBmpCharToGlyph(HDC hdc, SCRIPT_CACHE* scriptCache, const WCHAR utf16[2]) {
+uint16_t index = 0;
+// Use uniscribe to detemine glyph index for non-BMP characters.
+static const int numWCHAR = 2;
+static const int maxItems = 2;
+// MSDN states that this can be NULL, but some things don't work then.
+SCRIPT_CONTROL scriptControl = { 0 };
+// Add extra item to SCRIPT_ITEM to work around a bug (now documented).
+// https://bugzilla.mozilla.org/show_bug.cgi?id=366643
+SCRIPT_ITEM si[maxItems + 1];
+int numItems;
+HRZM(ScriptItemize(utf16, numWCHAR, maxItems, &scriptControl, NULL, si, &numItems),
+"Could not itemize character.");
+// Sometimes ScriptShape cannot find a glyph for a non-BMP and returns 2 space glyphs.
+static const int maxGlyphs = 2;
+SCRIPT_VISATTR vsa[maxGlyphs];
+WORD outGlyphs[maxGlyphs];
+WORD logClust[numWCHAR];
+int numGlyphs;
+HRZM(ScriptShape(hdc, scriptCache, utf16, numWCHAR, maxGlyphs, &si[0].a,
+outGlyphs, logClust, vsa, &numGlyphs),
+"Could not shape character.");
+if (1 == numGlyphs) {
+index = outGlyphs[0];
+}
+return index;
+}
+class SkAutoHDC {
+public:
+SkAutoHDC(const LOGFONT& lf)
+: fHdc(::CreateCompatibleDC(NULL))
+, fFont(::CreateFontIndirect(&lf))
+, fSavefont((HFONT)SelectObject(fHdc, fFont))
+{ }
+~SkAutoHDC() {
+SelectObject(fHdc, fSavefont);
+DeleteObject(fFont);
+DeleteDC(fHdc);
+}
+operator HDC() { return fHdc; }
+private:
+HDC fHdc;
+HFONT fFont;
+HFONT fSavefont;
+};
+#define SkAutoHDC(...) SK_REQUIRE_LOCAL_VAR(SkAutoHDC)
+int LogFontTypeface::onCharsToGlyphs(const void* chars, Encoding encoding,
+uint16_t userGlyphs[], int glyphCount) const
+{
+SkAutoHDC hdc(fLogFont);
+TEXTMETRIC tm;
+if (0 == GetTextMetrics(hdc, &tm)) {
+call_ensure_accessible(fLogFont);
+if (0 == GetTextMetrics(hdc, &tm)) {
+tm.tmPitchAndFamily = TMPF_TRUETYPE;
+}
+}
+bool Ox1FHack = !(tm.tmPitchAndFamily & TMPF_VECTOR) /*&& winVer < Vista */;
+SkAutoSTMalloc<256, uint16_t> scratchGlyphs;
+uint16_t* glyphs;
+if (userGlyphs != NULL) {
+glyphs = userGlyphs;
+} else {
+glyphs = scratchGlyphs.reset(glyphCount);
+}
+SCRIPT_CACHE sc = 0;
+switch (encoding) {
+case SkTypeface::kUTF8_Encoding: {
+static const int scratchCount = 256;
+WCHAR scratch[scratchCount];
+int glyphIndex = 0;
+const char* currentUtf8 = reinterpret_cast<const char*>(chars);
+SkUnichar currentChar;
+if (glyphCount) {
+currentChar = SkUTF8_NextUnichar(&currentUtf8);
+}
+while (glyphIndex < glyphCount) {
+// Try a run of bmp.
+int glyphsLeft = SkTMin(glyphCount - glyphIndex, scratchCount);
+int runLength = 0;
+while (runLength < glyphsLeft && currentChar <= 0xFFFF) {
+scratch[runLength] = static_cast<WCHAR>(currentChar);
+++runLength;
+if (runLength < glyphsLeft) {
+currentChar = SkUTF8_NextUnichar(&currentUtf8);
+}
+}
+if (runLength) {
+bmpCharsToGlyphs(hdc, scratch, runLength, &glyphs[glyphIndex], Ox1FHack);
+glyphIndex += runLength;
+}
+// Try a run of non-bmp.
+while (glyphIndex < glyphCount && currentChar > 0xFFFF) {
+SkUTF16_FromUnichar(currentChar, reinterpret_cast<uint16_t*>(scratch));
+glyphs[glyphIndex] = nonBmpCharToGlyph(hdc, &sc, scratch);
+++glyphIndex;
+if (glyphIndex < glyphCount) {
+currentChar = SkUTF8_NextUnichar(&currentUtf8);
+}
+}
+}
+break;
+}
+case SkTypeface::kUTF16_Encoding: {
+int glyphIndex = 0;
+const WCHAR* currentUtf16 = reinterpret_cast<const WCHAR*>(chars);
+while (glyphIndex < glyphCount) {
+// Try a run of bmp.
+int glyphsLeft = glyphCount - glyphIndex;
+int runLength = 0;
+while (runLength < glyphsLeft && !SkUTF16_IsHighSurrogate(currentUtf16[runLength])) {
+++runLength;
+}
+if (runLength) {
+bmpCharsToGlyphs(hdc, currentUtf16, runLength, &glyphs[glyphIndex], Ox1FHack);
+glyphIndex += runLength;
+currentUtf16 += runLength;
+}
+// Try a run of non-bmp.
+while (glyphIndex < glyphCount && SkUTF16_IsHighSurrogate(*currentUtf16)) {
+glyphs[glyphIndex] = nonBmpCharToGlyph(hdc, &sc, currentUtf16);
+++glyphIndex;
+currentUtf16 += 2;
+}
+}
+break;
+}
+case SkTypeface::kUTF32_Encoding: {
+static const int scratchCount = 256;
+WCHAR scratch[scratchCount];
+int glyphIndex = 0;
+const uint32_t* utf32 = reinterpret_cast<const uint32_t*>(chars);
+while (glyphIndex < glyphCount) {
+// Try a run of bmp.
+int glyphsLeft = SkTMin(glyphCount - glyphIndex, scratchCount);
+int runLength = 0;
+while (runLength < glyphsLeft && utf32[glyphIndex + runLength] <= 0xFFFF) {
+scratch[runLength] = static_cast<WCHAR>(utf32[glyphIndex + runLength]);
+++runLength;
+}
+if (runLength) {
+bmpCharsToGlyphs(hdc, scratch, runLength, &glyphs[glyphIndex], Ox1FHack);
+glyphIndex += runLength;
+}
+// Try a run of non-bmp.
+while (glyphIndex < glyphCount && utf32[glyphIndex] > 0xFFFF) {
+SkUTF16_FromUnichar(utf32[glyphIndex], reinterpret_cast<uint16_t*>(scratch));
+glyphs[glyphIndex] = nonBmpCharToGlyph(hdc, &sc, scratch);
+++glyphIndex;
+}
+}
+break;
+}
+default:
+SK_CRASH();
+}
+if (sc) {
+::ScriptFreeCache(&sc);
+}
+for (int i = 0; i < glyphCount; ++i) {
+if (0 == glyphs[i]) {
+return i;
+}
+}
+return glyphCount;
+}
+int LogFontTypeface::onCountGlyphs() const {
+HDC hdc = ::CreateCompatibleDC(NULL);
+HFONT font = CreateFontIndirect(&fLogFont);
+HFONT savefont = (HFONT)SelectObject(hdc, font);
+unsigned int glyphCount = calculateGlyphCount(hdc, fLogFont);
+SelectObject(hdc, savefont);
+DeleteObject(font);
+DeleteDC(hdc);
+return glyphCount;
+}
+int LogFontTypeface::onGetUPEM() const {
+HDC hdc = ::CreateCompatibleDC(NULL);
+HFONT font = CreateFontIndirect(&fLogFont);
+HFONT savefont = (HFONT)SelectObject(hdc, font);
+unsigned int upem = calculateUPEM(hdc, fLogFont);
+SelectObject(hdc, savefont);
+DeleteObject(font);
+DeleteDC(hdc);
+return upem;
+}
+SkTypeface::LocalizedStrings* LogFontTypeface::onCreateFamilyNameIterator() const {
+SkTypeface::LocalizedStrings* nameIter =
+SkOTUtils::LocalizedStrings_NameTable::CreateForFamilyNames(*this);
+if (NULL == nameIter) {
+SkString familyName;
+this->getFamilyName(&familyName);
+SkString language("und"); //undetermined
+nameIter = new SkOTUtils::LocalizedStrings_SingleName(familyName, language);
+}
+return nameIter;
+}
+int LogFontTypeface::onGetTableTags(SkFontTableTag tags[]) const {
+SkSFNTHeader header;
+if (sizeof(header) != this->onGetTableData(0, 0, sizeof(header), &header)) {
+return 0;
+}
+int numTables = SkEndian_SwapBE16(header.numTables);
+if (tags) {
+size_t size = numTables * sizeof(SkSFNTHeader::TableDirectoryEntry);
+SkAutoSTMalloc<0x20, SkSFNTHeader::TableDirectoryEntry> dir(numTables);
+if (size != this->onGetTableData(0, sizeof(header), size, dir.get())) {
+return 0;
+}
+for (int i = 0; i < numTables; ++i) {
+tags[i] = SkEndian_SwapBE32(dir[i].tag);
+}
+}
+return numTables;
+}
+size_t LogFontTypeface::onGetTableData(SkFontTableTag tag, size_t offset,
+size_t length, void* data) const
+{
+LOGFONT lf = fLogFont;
+HDC hdc = ::CreateCompatibleDC(NULL);
+HFONT font = CreateFontIndirect(&lf);
+HFONT savefont = (HFONT)SelectObject(hdc, font);
+tag = SkEndian_SwapBE32(tag);
+if (NULL == data) {
+length = 0;
+}
+DWORD bufferSize = GetFontData(hdc, tag, (DWORD) offset, data, (DWORD) length);
+if (bufferSize == GDI_ERROR) {
+call_ensure_accessible(lf);
+bufferSize = GetFontData(hdc, tag, (DWORD) offset, data, (DWORD) length);
+}
+SelectObject(hdc, savefont);
+DeleteObject(font);
+DeleteDC(hdc);
+return bufferSize == GDI_ERROR ? 0 : bufferSize;
+}
+SkScalerContext* LogFontTypeface::onCreateScalerContext(const SkDescriptor* desc) const {
+SkScalerContext_GDI* ctx = SkNEW_ARGS(SkScalerContext_GDI,
+(const_cast<LogFontTypeface*>(this), desc));
+if (!ctx->isValid()) {
+SkDELETE(ctx);
+ctx = NULL;
+}
+return ctx;
+}
+void LogFontTypeface::onFilterRec(SkScalerContextRec* rec) const {
+if (rec->fFlags & SkScalerContext::kLCD_BGROrder_Flag ||
+rec->fFlags & SkScalerContext::kLCD_Vertical_Flag)
+{
+rec->fMaskFormat = SkMask::kA8_Format;
+rec->fFlags |= SkScalerContext::kGenA8FromLCD_Flag;
+}
+unsigned flagsWeDontSupport = SkScalerContext::kDevKernText_Flag |
+SkScalerContext::kForceAutohinting_Flag |
+SkScalerContext::kEmbeddedBitmapText_Flag |
+SkScalerContext::kEmbolden_Flag |
+SkScalerContext::kLCD_BGROrder_Flag |
+SkScalerContext::kLCD_Vertical_Flag;
+rec->fFlags &= ~flagsWeDontSupport;
+SkPaint::Hinting h = rec->getHinting();
+switch (h) {
+case SkPaint::kNo_Hinting:
+break;
+case SkPaint::kSlight_Hinting:
+// Only do slight hinting when axis aligned.
+// TODO: re-enable slight hinting when FontHostTest can pass.
+//if (!isAxisAligned(*rec)) {
+h = SkPaint::kNo_Hinting;
+//}
+break;
+case SkPaint::kNormal_Hinting:
+case SkPaint::kFull_Hinting:
+// TODO: need to be able to distinguish subpixel positioned glyphs
+// and linear metrics.
+//rec->fFlags &= ~SkScalerContext::kSubpixelPositioning_Flag;
+h = SkPaint::kNormal_Hinting;
+break;
+default:
+SkDEBUGFAIL("unknown hinting");
+}
+//TODO: if this is a bitmap font, squash hinting and subpixel.
+rec->setHinting(h);
+// turn this off since GDI might turn A8 into BW! Need a bigger fix.
+#if 0
+// Disable LCD when rotated, since GDI's output is ugly
+if (isLCD(*rec) && !isAxisAligned(*rec)) {
+rec->fMaskFormat = SkMask::kA8_Format;
+}
+#endif
+if (!fCanBeLCD && isLCD(*rec)) {
+rec->fMaskFormat = SkMask::kA8_Format;
+rec->fFlags &= ~SkScalerContext::kGenA8FromLCD_Flag;
+}
+}
+///////////////////////////////////////////////////////////////////////////////
+#include "SkFontMgr.h"
+#include "SkDataTable.h"
+static bool valid_logfont_for_enum(const LOGFONT& lf) {
+// TODO: Vector FON is unsupported and should not be listed.
+return
+// Ignore implicit vertical variants.
+lf.lfFaceName[0] && lf.lfFaceName[0] != '@'
+// DEFAULT_CHARSET is used to get all fonts, but also implies all
+// character sets. Filter assuming all fonts support ANSI_CHARSET.
+&& ANSI_CHARSET == lf.lfCharSet
+;
+}
+/** An EnumFontFamExProc implementation which interprets builderParam as
+*  an SkTDArray<ENUMLOGFONTEX>* and appends logfonts which
+*  pass the valid_logfont_for_enum predicate.
+*/
+static int CALLBACK enum_family_proc(const LOGFONT* lf, const TEXTMETRIC*,
+DWORD fontType, LPARAM builderParam) {
+if (valid_logfont_for_enum(*lf)) {
+SkTDArray<ENUMLOGFONTEX>* array = (SkTDArray<ENUMLOGFONTEX>*)builderParam;
+*array->append() = *(ENUMLOGFONTEX*)lf;
+}
+return 1; // non-zero means continue
+}
+static SkFontStyle compute_fontstyle(const LOGFONT& lf) {
+return SkFontStyle(lf.lfWeight, SkFontStyle::kNormal_Width,
+lf.lfItalic ? SkFontStyle::kItalic_Slant
+: SkFontStyle::kUpright_Slant);
+}
+class SkFontStyleSetGDI : public SkFontStyleSet {
+public:
+SkFontStyleSetGDI(const TCHAR familyName[]) {
+LOGFONT lf;
+sk_bzero(&lf, sizeof(lf));
+lf.lfCharSet = DEFAULT_CHARSET;
+_tcscpy_s(lf.lfFaceName, familyName);
+HDC hdc = ::CreateCompatibleDC(NULL);
+::EnumFontFamiliesEx(hdc, &lf, enum_family_proc, (LPARAM)&fArray, 0);
+::DeleteDC(hdc);
+}
+virtual int count() SK_OVERRIDE {
+return fArray.count();
+}
+virtual void getStyle(int index, SkFontStyle* fs, SkString* styleName) SK_OVERRIDE {
+if (fs) {
+*fs = compute_fontstyle(fArray[index].elfLogFont);
+}
+if (styleName) {
+const ENUMLOGFONTEX& ref = fArray[index];
+// For some reason, ENUMLOGFONTEX and LOGFONT disagree on their type in the
+// non-unicode version.
+//      ENUMLOGFONTEX uses BYTE
+//      LOGFONT uses CHAR
+// Here we assert they that the style name is logically the same (size) as
+// a TCHAR, so we can use the same converter function.
+SkASSERT(sizeof(TCHAR) == sizeof(ref.elfStyle[0]));
+tchar_to_skstring((const TCHAR*)ref.elfStyle, styleName);
+}
+}
+virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
+return SkCreateTypefaceFromLOGFONT(fArray[index].elfLogFont);
+}
+virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
+// todo:
+return SkCreateTypefaceFromLOGFONT(fArray[0].elfLogFont);
+}
+private:
+SkTDArray<ENUMLOGFONTEX> fArray;
+};
+class SkFontMgrGDI : public SkFontMgr {
+public:
+SkFontMgrGDI() {
+LOGFONT lf;
+sk_bzero(&lf, sizeof(lf));
+lf.lfCharSet = DEFAULT_CHARSET;
+HDC hdc = ::CreateCompatibleDC(NULL);
+::EnumFontFamiliesEx(hdc, &lf, enum_family_proc, (LPARAM)&fLogFontArray, 0);
+::DeleteDC(hdc);
+}
+protected:
+virtual int onCountFamilies() const SK_OVERRIDE {
+return fLogFontArray.count();
+}
+virtual void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+SkASSERT((unsigned)index < (unsigned)fLogFontArray.count());
+tchar_to_skstring(fLogFontArray[index].elfLogFont.lfFaceName, familyName);
+}
+virtual SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
+SkASSERT((unsigned)index < (unsigned)fLogFontArray.count());
+return SkNEW_ARGS(SkFontStyleSetGDI, (fLogFontArray[index].elfLogFont.lfFaceName));
+}
+virtual SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+if (NULL == familyName) {
+familyName = "";    // do we need this check???
+}
+LOGFONT lf;
+logfont_for_name(familyName, &lf);
+return SkNEW_ARGS(SkFontStyleSetGDI, (lf.lfFaceName));
+}
+virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
+const SkFontStyle& fontstyle) const SK_OVERRIDE {
+// could be in base impl
+SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
+return sset->matchStyle(fontstyle);
+}
+virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
+const SkFontStyle& fontstyle) const SK_OVERRIDE {
+// could be in base impl
+SkString familyName;
+((LogFontTypeface*)familyMember)->getFamilyName(&familyName);
+return this->matchFamilyStyle(familyName.c_str(), fontstyle);
+}
+virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) const SK_OVERRIDE {
+return create_from_stream(stream);
+}
+virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
+// could be in base impl
+SkAutoTUnref<SkStream> stream(SkNEW_ARGS(SkMemoryStream, (data)));
+return this->createFromStream(stream);
+}
+virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+// could be in base impl
+SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
+return this->createFromStream(stream);
+}
+virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
+unsigned styleBits) const SK_OVERRIDE {
+LOGFONT lf;
+if (NULL == familyName) {
+lf = get_default_font();
+} else {
+logfont_for_name(familyName, &lf);
+}
+setStyle(&lf, (SkTypeface::Style)styleBits);
+return SkCreateTypefaceFromLOGFONT(lf);
+}
+private:
+SkTDArray<ENUMLOGFONTEX> fLogFontArray;
+};
+///////////////////////////////////////////////////////////////////////////////
+SkFontMgr* SkFontMgr_New_GDI() {
+return SkNEW(SkFontMgrGDI);
+}

The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/ports/SkFontHost_win.cpp

gfx/skia/trunk/src/ports/SkFontHost_win.cpp