move impl of AdvancedTypefaceMetrics into typeface (3)

src/ports/SkFontHost_win_dw.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTypes.h"
 #undef GetGlyphIndices
 
@@ skipping 463 matching lines @@
 
         IDWriteFactory* factory;
         HRVM(get_dwrite_factory(&factory), "Could not get factory.");
         HRV(factory->UnregisterFontCollectionLoader(fDWriteFontCollectionLoader.get()));
         HRV(factory->UnregisterFontFileLoader(fDWriteFontFileLoader.get()));
     }
 
 protected:
     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;
 };
 
 class SkScalerContext_Windows : public SkScalerContext {
 public:
     SkScalerContext_Windows(DWriteFontTypeface*, const SkDescriptor* desc);
     virtual ~SkScalerContext_Windows();
 
 protected:
     virtual unsigned generateGlyphCount() SK_OVERRIDE;
     virtual uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE;
@@ skipping 896 matching lines @@
 
     const T* fData;
     UINT32 fSize;
     BOOL fExists;
 private:
     //SkTScopedComPtr<IDWriteFontFace> fFontFace;
     IDWriteFontFace* fFontFace;
     void* fLock;
 };
 
-// static
-SkAdvancedTypefaceMetrics* SkFontHost::GetAdvancedTypefaceMetrics(
-        uint32_t fontID,
+SkAdvancedTypefaceMetrics* DWriteFontTypeface::onGetAdvancedTypefaceMetrics(
         SkAdvancedTypefaceMetrics::PerGlyphInfo perGlyphInfo,
         const uint32_t* glyphIDs,
-        uint32_t glyphIDsCount) {
+        uint32_t glyphIDsCount) const {
 
     SkAdvancedTypefaceMetrics* info = NULL;
 
     HRESULT hr = S_OK;
 
-    DWriteFontTypeface* typeface = GetDWriteFontByID(fontID);
-
-    const unsigned glyphCount = typeface->fDWriteFontFace->GetGlyphCount();
+    const unsigned glyphCount = fDWriteFontFace->GetGlyphCount();
 
     DWRITE_FONT_METRICS dwfm;
-    typeface->fDWriteFontFace->GetMetrics(&dwfm);
+    fDWriteFontFace->GetMetrics(&dwfm);
 
     info = new SkAdvancedTypefaceMetrics;
     info->fEmSize = dwfm.designUnitsPerEm;
     info->fMultiMaster = false;
     info->fLastGlyphID = SkToU16(glyphCount - 1);
     info->fStyle = 0;
 
 
     SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
     SkTScopedComPtr<IDWriteLocalizedStrings> faceNames;
-    hr = typeface->fDWriteFontFamily->GetFamilyNames(&familyNames);
-    hr = typeface->fDWriteFont->GetFaceNames(&faceNames);
+    hr = fDWriteFontFamily->GetFamilyNames(&familyNames);
+    hr = fDWriteFont->GetFaceNames(&faceNames);
 
     UINT32 familyNameLength;
     hr = familyNames->GetStringLength(0, &familyNameLength);
 
     UINT32 faceNameLength;
     hr = faceNames->GetStringLength(0, &faceNameLength);
 
     size_t size = familyNameLength+1+faceNameLength+1;
     SkTDArray<wchar_t> wFamilyName(new wchar_t[size], size);
     hr = familyNames->GetString(0, wFamilyName.begin(), size);
     wFamilyName[familyNameLength] = L' ';
     hr = faceNames->GetString(0, &wFamilyName[familyNameLength+1], size - faceNameLength + 1);
 
     size_t str_len = WideCharToMultiByte(CP_UTF8, 0, wFamilyName.begin(), -1, NULL, 0, NULL, NULL);
     if (0 == str_len) {
         //TODO: error
     }
     SkTDArray<char> familyName(new char[str_len], str_len);
     str_len = WideCharToMultiByte(CP_UTF8, 0, wFamilyName.begin(), -1, familyName.begin(), str_len, NULL, NULL);
     if (0 == str_len) {
         //TODO: error
     }
     info->fFontName.set(familyName.begin(), str_len);
 
     if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo) {
-        populate_glyph_to_unicode(typeface->fDWriteFontFace.get(), glyphCount, &(info->fGlyphToUnicode));
+        populate_glyph_to_unicode(fDWriteFontFace.get(), glyphCount, &(info->fGlyphToUnicode));
     }
 
-    DWRITE_FONT_FACE_TYPE fontType = typeface->fDWriteFontFace->GetType();
+    DWRITE_FONT_FACE_TYPE fontType = fDWriteFontFace->GetType();
     if (fontType == DWRITE_FONT_FACE_TYPE_TRUETYPE ||
         fontType == DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION) {
         info->fType = SkAdvancedTypefaceMetrics::kTrueType_Font;
     } else {
         info->fType = SkAdvancedTypefaceMetrics::kOther_Font;
         info->fItalicAngle = 0;
         info->fAscent = dwfm.ascent;;
         info->fDescent = dwfm.descent;
         info->fStemV = 0;
         info->fCapHeight = dwfm.capHeight;
         info->fBBox = SkIRect::MakeEmpty();
         return info;
     }
 
-    AutoDWriteTable<SkOTTableHead> headTable(typeface->fDWriteFontFace.get());
-    AutoDWriteTable<SkOTTablePostScript> postTable(typeface->fDWriteFontFace.get());
-    AutoDWriteTable<SkOTTableHorizontalHeader> hheaTable(typeface->fDWriteFontFace.get());
-    AutoDWriteTable<SkOTTableOS2> os2Table(typeface->fDWriteFontFace.get());
+    AutoDWriteTable<SkOTTableHead> headTable(fDWriteFontFace.get());
+    AutoDWriteTable<SkOTTablePostScript> postTable(fDWriteFontFace.get());
+    AutoDWriteTable<SkOTTableHorizontalHeader> hheaTable(fDWriteFontFace.get());
+    AutoDWriteTable<SkOTTableOS2> os2Table(fDWriteFontFace.get());
     if (!headTable.fExists || !postTable.fExists || !hheaTable.fExists || !os2Table.fExists) {
         info->fItalicAngle = 0;
         info->fAscent = dwfm.ascent;;
         info->fDescent = dwfm.descent;
         info->fStemV = 0;
         info->fCapHeight = dwfm.capHeight;
         info->fBBox = SkIRect::MakeEmpty();
         return info;
     }
 
@@ skipping 53 matching lines @@
 
     // If Restricted, the font may not be embedded in a document.
     // If not Restricted, the font can be embedded.
     // If PreviewPrint, the embedding is read-only.
     if (os2Table->version.v0.fsType.field.Restricted) {
         info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
     } else if (perGlyphInfo & SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) {
         if (fixedWidth) {
             appendRange(&info->fGlyphWidths, 0);
             int16_t advance;
-            getWidthAdvance(typeface->fDWriteFontFace.get(), 1, &advance);
+            getWidthAdvance(fDWriteFontFace.get(), 1, &advance);
             info->fGlyphWidths->fAdvance.append(1, &advance);
             finishRange(info->fGlyphWidths.get(), 0,
                         SkAdvancedTypefaceMetrics::WidthRange::kDefault);
         } else {
             info->fGlyphWidths.reset(
-                getAdvanceData(typeface->fDWriteFontFace.get(),
+                getAdvanceData(fDWriteFontFace.get(),
                                glyphCount,
                                glyphIDs,
                                glyphIDsCount,
                                getWidthAdvance));
         }
     }
 
     return info;
 }