Revert of Pdfium: Fix fonts leaking on ClosePage.

core/fxge/ge/cfx_renderdevice.cpp

 // Copyright 2016 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fxge/include/cfx_renderdevice.h"
 
 #include "core/fxcrt/include/fx_safe_types.h"
 #include "core/fxge/include/cfx_autofontcache.h"
 #include "core/fxge/include/cfx_facecache.h"
+#include "core/fxge/include/cfx_fontcache.h"
 #include "core/fxge/include/cfx_fxgedevice.h"
 #include "core/fxge/include/cfx_graphstatedata.h"
 #include "core/fxge/include/cfx_pathdata.h"
 #include "core/fxge/include/ifx_renderdevicedriver.h"
 
 #if defined _SKIA_SUPPORT_
 #include "third_party/skia/include/core/SkTypes.h"
 #endif
 
 namespace {
@@ skipping 794 matching lines @@
                                        int bitmap_alpha,
                                        int blend_type) {
   return m_pDeviceDriver->SetBitsWithMask(pBitmap, pMask, left, top,
                                           bitmap_alpha, blend_type);
 }
 #endif
 
 FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars,
                                          const FXTEXT_CHARPOS* pCharPos,
                                          CFX_Font* pFont,
+                                         CFX_FontCache* pCache,
                                          FX_FLOAT font_size,
                                          const CFX_Matrix* pText2Device,
                                          uint32_t fill_color,
                                          uint32_t text_flags) {
   int nativetext_flags = text_flags;
   if (m_DeviceClass != FXDC_DISPLAY) {
     if (!(text_flags & FXTEXT_PRINTGRAPHICTEXT)) {
       if (ShouldDrawDeviceText(pFont, text_flags) &&
-          m_pDeviceDriver->DrawDeviceText(nChars, pCharPos, pFont, pText2Device,
-                                          font_size, fill_color)) {
+          m_pDeviceDriver->DrawDeviceText(nChars, pCharPos, pFont, pCache,
+                                          pText2Device, font_size,
+                                          fill_color)) {
         return TRUE;
       }
     }
     if (FXARGB_A(fill_color) < 255)
       return FALSE;
   } else if (!(text_flags & FXTEXT_NO_NATIVETEXT)) {
     if (ShouldDrawDeviceText(pFont, text_flags) &&
-        m_pDeviceDriver->DrawDeviceText(nChars, pCharPos, pFont, pText2Device,
-                                        font_size, fill_color)) {
+        m_pDeviceDriver->DrawDeviceText(nChars, pCharPos, pFont, pCache,
+                                        pText2Device, font_size, fill_color)) {
       return TRUE;
     }
   }
   CFX_Matrix char2device;
   CFX_Matrix text2Device;
   if (pText2Device) {
     char2device = *pText2Device;
     text2Device = *pText2Device;
   }
   char2device.Scale(font_size, -font_size);
   if (FXSYS_fabs(char2device.a) + FXSYS_fabs(char2device.b) > 50 * 1.0f ||
       ((m_DeviceClass == FXDC_PRINTER) &&
        !(text_flags & FXTEXT_PRINTIMAGETEXT))) {
     if (pFont->GetFace() ||
         (pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
       int nPathFlags =
           (text_flags & FXTEXT_NOSMOOTH) == 0 ? 0 : FXFILL_NOPATHSMOOTH;
-      return DrawTextPath(nChars, pCharPos, pFont, font_size, pText2Device,
-                          nullptr, nullptr, fill_color, 0, nullptr, nPathFlags);
+      return DrawTextPath(nChars, pCharPos, pFont, pCache, font_size,
+                          pText2Device, nullptr, nullptr, fill_color, 0,
+                          nullptr, nPathFlags);
     }
   }
   int anti_alias = FXFT_RENDER_MODE_MONO;
   bool bNormal = false;
   if ((text_flags & FXTEXT_NOSMOOTH) == 0) {
     if (m_DeviceClass == FXDC_DISPLAY && m_bpp > 1) {
       if (!CFX_GEModule::Get()->GetFontMgr()->FTLibrarySupportsHinting()) {
         // Some Freetype implementations (like the one packaged with Fedora) do
         // not support hinting due to patents 6219025, 6239783, 6307566,
         // 6225973, 6243070, 6393145, 6421054, 6282327, and 6624828; the latest
@@ skipping 10 matching lines @@
 
         bool bClearType = false;
         if (pFont->GetFace() ||
             (pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_CLEARTYPE)) {
           bClearType = !!(text_flags & FXTEXT_CLEARTYPE);
         }
         bNormal = !bClearType;
       }
     }
   }
+  if (!pCache)
+    pCache = CFX_GEModule::Get()->GetFontCache();
+  CFX_FaceCache* pFaceCache = pCache->GetCachedFace(pFont);
+  CFX_AutoFontCache autoFontCache(pCache, pFont);
   std::vector<FXTEXT_GLYPHPOS> glyphs(nChars);
   CFX_Matrix matrixCTM = GetCTM();
   FX_FLOAT scale_x = FXSYS_fabs(matrixCTM.a);
   FX_FLOAT scale_y = FXSYS_fabs(matrixCTM.d);
   CFX_Matrix deviceCtm = char2device;
   deviceCtm.Concat(scale_x, 0, 0, scale_y, 0, 0);
   text2Device.Concat(scale_x, 0, 0, scale_y, 0, 0);
   for (size_t i = 0; i < glyphs.size(); ++i) {
     FXTEXT_GLYPHPOS& glyph = glyphs[i];
     const FXTEXT_CHARPOS& charpos = pCharPos[i];
     glyph.m_fOriginX = charpos.m_OriginX;
     glyph.m_fOriginY = charpos.m_OriginY;
     text2Device.Transform(glyph.m_fOriginX, glyph.m_fOriginY);
     if (anti_alias < FXFT_RENDER_MODE_LCD)
       glyph.m_OriginX = FXSYS_round(glyph.m_fOriginX);
     else
       glyph.m_OriginX = (int)FXSYS_floor(glyph.m_fOriginX);
     glyph.m_OriginY = FXSYS_round(glyph.m_fOriginY);
     if (charpos.m_bGlyphAdjust) {
       CFX_Matrix new_matrix(
           charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
           charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
       new_matrix.Concat(deviceCtm);
-      glyph.m_pGlyph = pFont->LoadGlyphBitmap(
-          charpos.m_GlyphIndex, charpos.m_bFontStyle, &new_matrix,
+      glyph.m_pGlyph = pFaceCache->LoadGlyphBitmap(
+          pFont, charpos.m_GlyphIndex, charpos.m_bFontStyle, &new_matrix,
           charpos.m_FontCharWidth, anti_alias, nativetext_flags);
     } else {
-      glyph.m_pGlyph = pFont->LoadGlyphBitmap(
-          charpos.m_GlyphIndex, charpos.m_bFontStyle, &deviceCtm,
+      glyph.m_pGlyph = pFaceCache->LoadGlyphBitmap(
+          pFont, charpos.m_GlyphIndex, charpos.m_bFontStyle, &deviceCtm,
           charpos.m_FontCharWidth, anti_alias, nativetext_flags);
     }
   }
   if (anti_alias < FXFT_RENDER_MODE_LCD && glyphs.size() > 1)
     AdjustGlyphSpace(&glyphs);
 
   FX_RECT bmp_rect1 = FXGE_GetGlyphsBBox(glyphs, anti_alias);
   if (scale_x > 1 && scale_y > 1) {
     bmp_rect1.left--;
     bmp_rect1.top--;
@@ skipping 100 matching lines @@
   if (bitmap.IsAlphaMask())
     SetBitMask(&bitmap, bmp_rect.left, bmp_rect.top, fill_color);
   else
     SetDIBits(&bitmap, bmp_rect.left, bmp_rect.top);
   return TRUE;
 }
 
 FX_BOOL CFX_RenderDevice::DrawTextPath(int nChars,
                                        const FXTEXT_CHARPOS* pCharPos,
                                        CFX_Font* pFont,
+                                       CFX_FontCache* pCache,
                                        FX_FLOAT font_size,
                                        const CFX_Matrix* pText2User,
                                        const CFX_Matrix* pUser2Device,
                                        const CFX_GraphStateData* pGraphState,
                                        uint32_t fill_color,
                                        FX_ARGB stroke_color,
                                        CFX_PathData* pClippingPath,
                                        int nFlag) {
+  if (!pCache)
+    pCache = CFX_GEModule::Get()->GetFontCache();
+  CFX_FaceCache* pFaceCache = pCache->GetCachedFace(pFont);
+  CFX_AutoFontCache autoFontCache(pCache, pFont);
   for (int iChar = 0; iChar < nChars; iChar++) {
     const FXTEXT_CHARPOS& charpos = pCharPos[iChar];
     CFX_Matrix matrix;
     if (charpos.m_bGlyphAdjust) {
       matrix.Set(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
                  charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
     }
     matrix.Concat(font_size, 0, 0, font_size, charpos.m_OriginX,
                   charpos.m_OriginY);
-    const CFX_PathData* pPath =
-        pFont->LoadGlyphPath(charpos.m_GlyphIndex, charpos.m_FontCharWidth);
+    const CFX_PathData* pPath = pFaceCache->LoadGlyphPath(
+        pFont, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
     if (!pPath)
       continue;
     matrix.Concat(*pText2User);
     CFX_PathData TransformedPath(*pPath);
     TransformedPath.Transform(&matrix);
     if (fill_color || stroke_color) {
       int fill_mode = nFlag;
       if (fill_color)
         fill_mode |= FXFILL_WINDING;
       fill_mode |= FX_FILL_TEXT_MODE;
       if (!DrawPathWithBlend(&TransformedPath, pUser2Device, pGraphState,
                              fill_color, stroke_color, fill_mode,
                              FXDIB_BLEND_NORMAL)) {
         return FALSE;
       }
     }
     if (pClippingPath)
       pClippingPath->Append(&TransformedPath, pUser2Device);
   }
   return TRUE;
 }