Make CFX_FontCache global

core/fpdfapi/fpdf_render/fpdf_render_text.cpp

 // Copyright 2014 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/fpdfapi/fpdf_render/render_int.h"
 
 #include <vector>
 
 #include "core/fpdfapi/fpdf_font/cpdf_cidfont.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type3char.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type3font.h"
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_form.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_imageobject.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_pageobject.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_pathobject.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_textobject.h"
 #include "core/fpdfapi/fpdf_page/pageint.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_render/cpdf_type3cache.h"
 #include "core/fpdfapi/fpdf_render/include/cpdf_renderoptions.h"
 #include "core/fpdfapi/fpdf_render/include/cpdf_textrenderer.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_gemodule.h"
 #include "core/fxge/include/cfx_graphstatedata.h"
 #include "core/fxge/include/cfx_pathdata.h"
 #include "core/fxge/include/cfx_renderdevice.h"
 
 FX_BOOL CPDF_RenderStatus::ProcessText(CPDF_TextObject* textobj,
                                        const CFX_Matrix* pObj2Device,
                                        CFX_PathData* pClippingPath) {
   if (textobj->m_nChars == 0)
@@ skipping 389 matching lines @@
                                         FX_FLOAT* pCharPos,
                                         CPDF_Font* pFont,
                                         FX_FLOAT font_size,
                                         const CFX_Matrix* pText2User,
                                         const CFX_Matrix* pUser2Device,
                                         const CFX_GraphStateData* pGraphState,
                                         FX_ARGB fill_argb,
                                         FX_ARGB stroke_argb,
                                         CFX_PathData* pClippingPath,
                                         int nFlag) {
-  CFX_FontCache* pCache =
-      pFont->m_pDocument ? pFont->m_pDocument->GetRenderData()->GetFontCache()
-                         : nullptr;
   CPDF_CharPosList CharPosList;
   CharPosList.Load(nChars, pCharCodes, pCharPos, pFont, font_size);
   if (CharPosList.m_nChars == 0)
     return TRUE;
   bool bDraw = true;
   int32_t fontPosition = CharPosList.m_pCharPos[0].m_FallbackFontPosition;
   uint32_t startIndex = 0;
   for (uint32_t i = 0; i < CharPosList.m_nChars; i++) {
     int32_t curFontPosition = CharPosList.m_pCharPos[i].m_FallbackFontPosition;
     if (fontPosition == curFontPosition)
       continue;
     auto* font = fontPosition == -1
                      ? &pFont->m_Font
                      : pFont->m_FontFallbacks[fontPosition].get();
-    if (!pDevice->DrawTextPath(
-            i - startIndex, CharPosList.m_pCharPos + startIndex, font, pCache,
-            font_size, pText2User, pUser2Device, pGraphState, fill_argb,
-            stroke_argb, pClippingPath, nFlag)) {
+    if (!pDevice->DrawTextPath(i - startIndex,
+                               CharPosList.m_pCharPos + startIndex, font,
+                               font_size, pText2User, pUser2Device, pGraphState,
+                               fill_argb, stroke_argb, pClippingPath, nFlag)) {
       bDraw = false;
     }
     fontPosition = curFontPosition;
     startIndex = i;
   }
   auto* font = fontPosition == -1 ? &pFont->m_Font
                                   : pFont->m_FontFallbacks[fontPosition].get();
   if (!pDevice->DrawTextPath(CharPosList.m_nChars - startIndex,
-                             CharPosList.m_pCharPos + startIndex, font, pCache,
+                             CharPosList.m_pCharPos + startIndex, font,
                              font_size, pText2User, pUser2Device, pGraphState,
                              fill_argb, stroke_argb, pClippingPath, nFlag)) {
     bDraw = false;
   }
   return bDraw;
 }
 
 // static
 void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice,
                                        FX_FLOAT origin_x,
@@ skipping 55 matching lines @@
 // static
 FX_BOOL CPDF_TextRenderer::DrawNormalText(CFX_RenderDevice* pDevice,
                                           int nChars,
                                           uint32_t* pCharCodes,
                                           FX_FLOAT* pCharPos,
                                           CPDF_Font* pFont,
                                           FX_FLOAT font_size,
                                           const CFX_Matrix* pText2Device,
                                           FX_ARGB fill_argb,
                                           const CPDF_RenderOptions* pOptions) {
-  CFX_FontCache* pCache =
-      pFont->m_pDocument ? pFont->m_pDocument->GetRenderData()->GetFontCache()
-                         : nullptr;
   CPDF_CharPosList CharPosList;
   CharPosList.Load(nChars, pCharCodes, pCharPos, pFont, font_size);
   if (CharPosList.m_nChars == 0)
     return TRUE;
   int FXGE_flags = 0;
   if (pOptions) {
     uint32_t dwFlags = pOptions->m_Flags;
     if (dwFlags & RENDER_CLEARTYPE) {
       FXGE_flags |= FXTEXT_CLEARTYPE;
       if (dwFlags & RENDER_BGR_STRIPE) {
@@ skipping 22 matching lines @@
   int32_t fontPosition = CharPosList.m_pCharPos[0].m_FallbackFontPosition;
   uint32_t startIndex = 0;
   for (uint32_t i = 0; i < CharPosList.m_nChars; i++) {
     int32_t curFontPosition = CharPosList.m_pCharPos[i].m_FallbackFontPosition;
     if (fontPosition == curFontPosition)
       continue;
     auto* font = fontPosition == -1
                      ? &pFont->m_Font
                      : pFont->m_FontFallbacks[fontPosition].get();
     if (!pDevice->DrawNormalText(
-            i - startIndex, CharPosList.m_pCharPos + startIndex, font, pCache,
+            i - startIndex, CharPosList.m_pCharPos + startIndex, font,
             font_size, pText2Device, fill_argb, FXGE_flags)) {
       bDraw = false;
     }
     fontPosition = curFontPosition;
     startIndex = i;
   }
   auto* font = fontPosition == -1 ? &pFont->m_Font
                                   : pFont->m_FontFallbacks[fontPosition].get();
   if (!pDevice->DrawNormalText(CharPosList.m_nChars - startIndex,
                                CharPosList.m_pCharPos + startIndex, font,
-                               pCache, font_size, pText2Device, fill_argb,
+                               font_size, pText2Device, fill_argb,
                                FXGE_flags)) {
     bDraw = false;
   }
   return bDraw;
 }
 
 void CPDF_RenderStatus::DrawTextPathWithPattern(const CPDF_TextObject* textobj,
                                                 const CFX_Matrix* pObj2Device,
                                                 CPDF_Font* pFont,
                                                 FX_FLOAT font_size,
@@ skipping 10 matching lines @@
     path.m_ColorState = textobj->m_ColorState;
     path.m_Path.AppendRect(textobj->m_Left, textobj->m_Bottom, textobj->m_Right,
                            textobj->m_Top);
     path.m_Left = textobj->m_Left;
     path.m_Bottom = textobj->m_Bottom;
     path.m_Right = textobj->m_Right;
     path.m_Top = textobj->m_Top;
     RenderSingleObject(&path, pObj2Device);
     return;
   }
-  CFX_FontCache* pCache;
-  if (pFont->m_pDocument) {
-    pCache = pFont->m_pDocument->GetRenderData()->GetFontCache();
-  } else {
-    pCache = CFX_GEModule::Get()->GetFontCache();
-  }
   CPDF_CharPosList CharPosList;
   CharPosList.Load(textobj->m_nChars, textobj->m_pCharCodes,
                    textobj->m_pCharPos, pFont, font_size);
-  std::vector<CFX_FaceCache*> faceCaches;
-  std::vector<CFX_AutoFontCache> autoFontCaches;
-  faceCaches.push_back(pCache->GetCachedFace(&pFont->m_Font));
-  autoFontCaches.push_back(CFX_AutoFontCache(pCache, &pFont->m_Font));
-  for (const auto& font : pFont->m_FontFallbacks) {
-    faceCaches.push_back(pCache->GetCachedFace(font.get()));
-    autoFontCaches.push_back(CFX_AutoFontCache(pCache, font.get()));
-  }
   for (uint32_t i = 0; i < CharPosList.m_nChars; i++) {
     FXTEXT_CHARPOS& charpos = CharPosList.m_pCharPos[i];
     auto font =
         charpos.m_FallbackFontPosition == -1
             ? &pFont->m_Font
             : pFont->m_FontFallbacks[charpos.m_FallbackFontPosition].get();
     const CFX_PathData* pPath =
-        faceCaches[charpos.m_FallbackFontPosition + 1]->LoadGlyphPath(
-            font, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
+        font->LoadGlyphPath(charpos.m_GlyphIndex, charpos.m_FontCharWidth);
     if (!pPath) {
       continue;
     }
     CPDF_PathObject path;
     path.m_GraphState = textobj->m_GraphState;
     path.m_ColorState = textobj->m_ColorState;
     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);
     path.m_Path.Append(pPath, &matrix);
     path.m_Matrix = *pTextMatrix;
     path.m_bStroke = bStroke;
     path.m_FillType = bFill ? FXFILL_WINDING : 0;
     path.CalcBoundingBox();
     ProcessPath(&path, pObj2Device);
   }
 }