Pdfium: Fix fonts leaking on ClosePage.

core/fxge/skia/fx_skia_device.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.
 
 #if defined(_SKIA_SUPPORT_)
 #include <algorithm>
 #include <vector>
 
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxcrt/include/fx_memory.h"
 
 #include "core/fpdfapi/fpdf_page/cpdf_shadingpattern.h"
 #include "core/fpdfapi/fpdf_page/pageint.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.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"
 #include "core/fxge/skia/fx_skia_device.h"
 
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
@@ skipping 451 matching lines @@
 class SkiaState {
  public:
   enum class Clip {
     kSave,
     kPath,
   };
 
   // mark all cached state as uninitialized
   SkiaState()
       : m_pFont(nullptr),
-        m_pCache(nullptr),
         m_fontSize(0),
         m_fillColor(0),
         m_strokeColor(0),
         m_blendType(0),
         m_commandIndex(0),
         m_drawText(false),
         m_drawPath(false),
         m_fillPath(false),
         m_debugDisable(false) {}
 
@@ skipping 73 matching lines @@
       skPaint.setColor(m_strokeColor);
       skCanvas->drawPath(m_skPath, skPaint);
     }
     skCanvas->restore();
     m_drawPath = false;
   }
 
   bool DrawText(int nChars,
                 const FXTEXT_CHARPOS* pCharPos,
                 CFX_Font* pFont,
-                CFX_FontCache* pCache,
                 const CFX_Matrix* pMatrix,
                 FX_FLOAT font_size,
                 uint32_t color,
                 CFX_SkiaDeviceDriver* pDriver) {
     if (m_debugDisable)
       return false;
     if (m_commandIndex < m_commands.count())
       FlushCommands(pDriver);
     if (m_drawPath)
       FlushPath(pDriver);
-    if (m_drawText && FontChanged(pFont, pCache, pMatrix, font_size, color))
+    if (m_drawText && FontChanged(pFont, pMatrix, font_size, color))
       FlushText(pDriver);
     if (!m_drawText) {
       m_positions.setCount(0);
       m_glyphs.setCount(0);
       m_pFont = pFont;
-      m_pCache = pCache;
       m_fontSize = font_size;
       m_fillColor = color;
       m_drawMatrix = *pMatrix;
     }
     int count = m_positions.count();
     m_positions.setCount(nChars + count);
     m_glyphs.setCount(nChars + count);
     SkScalar flip = m_fontSize < 0 ? -1 : 1;
     for (int index = 0; index < nChars; ++index) {
       const FXTEXT_CHARPOS& cp = pCharPos[index];
       m_positions[index + count] = {cp.m_OriginX * flip, cp.m_OriginY * flip};
       m_glyphs[index + count] = (uint16_t)cp.m_GlyphIndex;
     }
     SkPoint delta;
     if (MatrixOffset(pMatrix, &delta)) {
       for (int index = 0; index < nChars; ++index)
         m_positions[index + count].offset(delta.fX * flip, -delta.fY * flip);
     }
     m_drawText = true;
     return true;
   }
 
   void FlushText(CFX_SkiaDeviceDriver* pDriver) {
     SkScalar flip = m_fontSize < 0 ? -1 : 1;
     SkMatrix skMatrix = ToFlippedSkMatrix(m_drawMatrix, flip);
     SkPaint skPaint;
     skPaint.setAntiAlias(true);
     skPaint.setColor(m_fillColor);
-    if (m_pFont->GetFace() && m_pCache) {  // exclude placeholder test fonts
-      sk_sp<SkTypeface> typeface(SkSafeRef(m_pCache->GetDeviceCache(m_pFont)));
+    if (m_pFont->GetFace()) {  // exclude placeholder test fonts
+      sk_sp<SkTypeface> typeface(SkSafeRef(m_pFont->GetDeviceCache()));
       skPaint.setTypeface(typeface);
     }
     skPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
     skPaint.setTextSize(m_fontSize);
     skPaint.setSubpixelText(true);
     skPaint.setHinting(SkPaint::kNo_Hinting);
     SkCanvas* skCanvas = pDriver->SkiaCanvas();
     skCanvas->save();
     skCanvas->concat(skMatrix);
     skCanvas->drawPosText(m_glyphs.begin(), m_glyphs.count() * 2,
@@ skipping 135 matching lines @@
                    int blend_type) {
     return MatrixChanged(pMatrix, m_drawMatrix) ||
            StateChanged(pState, m_drawState) || fill_color != m_fillColor ||
            stroke_color != m_strokeColor ||
            ((fill_mode & 3) == FXFILL_ALTERNATE) !=
                (m_skPath.getFillType() == SkPath::kEvenOdd_FillType) ||
            blend_type != m_blendType;
   }
 
   bool FontChanged(CFX_Font* pFont,
-                   CFX_FontCache* pCache,
                    const CFX_Matrix* pMatrix,
                    FX_FLOAT font_size,
                    uint32_t color) {
-    return pFont != m_pFont || pCache != m_pCache ||
-           MatrixChanged(pMatrix, m_drawMatrix) || font_size != m_fontSize ||
-           color != m_fillColor;
+    return pFont != m_pFont || MatrixChanged(pMatrix, m_drawMatrix) ||
+           font_size != m_fontSize || color != m_fillColor;
   }
 
   bool MatrixChanged(const CFX_Matrix* pMatrix, const CFX_Matrix& refMatrix) {
     CFX_Matrix identityMatrix;
     if (!pMatrix)
       pMatrix = &identityMatrix;
     return pMatrix->a != refMatrix.a || pMatrix->b != refMatrix.b ||
            pMatrix->c != refMatrix.c || pMatrix->d != refMatrix.d;
   }
 
@@ skipping 62 matching lines @@
   SkTDArray<Clip> m_commands;      // stack of clip-related commands
   SkTDArray<SkPoint> m_positions;  // accumulator for text positions
   SkTDArray<uint16_t> m_glyphs;    // accumulator for text glyphs
   SkPath m_skPath;                 // accumulator for path contours
   SkPath m_skEmptyPath;            // used as placehold in the clips array
   CFX_Matrix m_drawMatrix;
   CFX_GraphStateData m_clipState;
   CFX_GraphStateData m_drawState;
   CFX_Matrix m_clipMatrix;
   CFX_Font* m_pFont;
-  CFX_FontCache* m_pCache;
   FX_FLOAT m_fontSize;
   uint32_t m_fillColor;
   uint32_t m_strokeColor;
   int m_blendType;
   int m_commandIndex;  // active position in clip command stack
   bool m_drawText;
   bool m_drawPath;
   bool m_fillPath;
   bool m_debugDisable;  // turn off cache for debugging
 };
@@ skipping 112 matching lines @@
 }
 
 void CFX_SkiaDeviceDriver::Flush() {
   m_pCache->Flush(this);
   m_pCache->FlushCommands(this);
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars,
                                              const FXTEXT_CHARPOS* pCharPos,
                                              CFX_Font* pFont,
-                                             CFX_FontCache* pCache,
                                              const CFX_Matrix* pObject2Device,
                                              FX_FLOAT font_size,
                                              uint32_t color) {
-  if (!pCache)
-    pCache = CFX_GEModule::Get()->GetFontCache();
-  if (m_pCache->DrawText(nChars, pCharPos, pFont, pCache, pObject2Device,
-                         font_size, color, this)) {
+  if (m_pCache->DrawText(nChars, pCharPos, pFont, pObject2Device, font_size,
+                         color, this)) {
     return TRUE;
   }
-  sk_sp<SkTypeface> typeface(
-      SkSafeRef(pCache ? pCache->GetDeviceCache(pFont) : nullptr));
+  sk_sp<SkTypeface> typeface(SkSafeRef(pFont->GetDeviceCache()));
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(color);
   paint.setTypeface(typeface);
   paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   paint.setHinting(SkPaint::kNo_Hinting);
   paint.setTextSize(font_size);
   paint.setSubpixelText(true);
   m_pCanvas->save();
   SkScalar flip = font_size < 0 ? -1 : 1;
@@ skipping 653 matching lines @@
       SkA32Assert(a);
       SkASSERT(r <= a);
       SkASSERT(g <= a);
       SkASSERT(b <= a);
     }
   }
 #endif
 }
 
 #endif