Clean up CPDF_TextRenderer slightly.

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>
 
@@ skipping 510 matching lines @@
             FX_FLOAT* pCharPos,
             CPDF_Font* pFont,
             FX_FLOAT font_size);
   FXTEXT_CHARPOS* m_pCharPos;
   uint32_t m_nChars;
 };
 
 CPDF_CharPosList::CPDF_CharPosList() {
   m_pCharPos = NULL;
 }
+
 CPDF_CharPosList::~CPDF_CharPosList() {
   FX_Free(m_pCharPos);
 }
+
 void CPDF_CharPosList::Load(int nChars,
                             uint32_t* pCharCodes,
                             FX_FLOAT* pCharPos,
                             CPDF_Font* pFont,
                             FX_FLOAT FontSize) {
   m_pCharPos = FX_Alloc(FXTEXT_CHARPOS, nChars);
   m_nChars = 0;
   CPDF_CIDFont* pCIDFont = pFont->AsCIDFont();
   FX_BOOL bVertWriting = pCIDFont && pCIDFont->IsVertWriting();
   for (int iChar = 0; iChar < nChars; iChar++) {
@@ skipping 39 matching lines @@
       charpos.m_AdjustMatrix[3] = pCIDFont->CIDTransformToFloat(pTransform[3]);
       charpos.m_OriginX +=
           pCIDFont->CIDTransformToFloat(pTransform[4]) * FontSize;
       charpos.m_OriginY +=
           pCIDFont->CIDTransformToFloat(pTransform[5]) * FontSize;
       charpos.m_bGlyphAdjust = TRUE;
     }
   }
 }
 
+// static
 FX_BOOL CPDF_TextRenderer::DrawTextPath(CFX_RenderDevice* pDevice,
                                         int nChars,
                                         uint32_t* pCharCodes,
                                         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);
   return pDevice->DrawTextPathWithFlags(
       CharPosList.m_nChars, CharPosList.m_pCharPos, &pFont->m_Font, pCache,
       font_size, pText2User, pUser2Device, pGraphState, fill_argb, stroke_argb,
       pClippingPath, nFlag);
 }
 
-void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice,
-                                       int left,
-                                       int top,
-                                       CPDF_Font* pFont,
-                                       int height,
-                                       const CFX_ByteString& str,
-                                       FX_ARGB argb) {
-  FX_RECT font_bbox;
-  pFont->GetFontBBox(font_bbox);
-  FX_FLOAT font_size =
-      (FX_FLOAT)height * 1000.0f / (FX_FLOAT)(font_bbox.top - font_bbox.bottom);
-  FX_FLOAT origin_x = (FX_FLOAT)left;
-  FX_FLOAT origin_y =
-      (FX_FLOAT)top + font_size * (FX_FLOAT)font_bbox.top / 1000.0f;
-  CFX_Matrix matrix(1.0f, 0, 0, -1.0f, 0, 0);
-  DrawTextString(pDevice, origin_x, origin_y, pFont, font_size, &matrix, str,
-                 argb);
-}
+// static
 void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice,
                                        FX_FLOAT origin_x,
                                        FX_FLOAT origin_y,
                                        CPDF_Font* pFont,
                                        FX_FLOAT font_size,
                                        const CFX_Matrix* pMatrix,
                                        const CFX_ByteString& str,
                                        FX_ARGB fill_argb,
                                        FX_ARGB stroke_argb,
                                        const CFX_GraphStateData* pGraphState,
@@ skipping 28 matching lines @@
 
   matrix.e = origin_x;
   matrix.f = origin_y;
 
   if (!pFont->IsType3Font()) {
     if (stroke_argb == 0) {
       DrawNormalText(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
                      &matrix, fill_argb, pOptions);
     } else {
       DrawTextPath(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
-                   &matrix, NULL, pGraphState, fill_argb, stroke_argb, NULL);
+                   &matrix, nullptr, pGraphState, fill_argb, stroke_argb,
+                   nullptr, 0);
     }
   }
 
   if (nChars > 1) {
     FX_Free(pCharCodes);
     FX_Free(pCharPos);
   }
 }
+
+// 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 =
@@ skipping 25 matching lines @@
   } else {
     FXGE_flags = FXTEXT_CLEARTYPE;
   }
   if (pFont->IsCIDFont()) {
     FXGE_flags |= FXFONT_CIDFONT;
   }
   return pDevice->DrawNormalText(CharPosList.m_nChars, CharPosList.m_pCharPos,
                                  &pFont->m_Font, pCache, font_size,
                                  pText2Device, fill_argb, FXGE_flags);
 }
+
 void CPDF_RenderStatus::DrawTextPathWithPattern(const CPDF_TextObject* textobj,
                                                 const CFX_Matrix* pObj2Device,
                                                 CPDF_Font* pFont,
                                                 FX_FLOAT font_size,
                                                 const CFX_Matrix* pTextMatrix,
                                                 FX_BOOL bFill,
                                                 FX_BOOL bStroke) {
   if (!bStroke) {
     CPDF_PathObject path;
     std::vector<std::unique_ptr<CPDF_TextObject>> pCopy;
@@ skipping 39 matching lines @@
     matrix.Concat(font_size, 0, 0, font_size, charpos.m_OriginX,
                   charpos.m_OriginY);
     path.m_Path.New()->Append(pPath, &matrix);
     path.m_Matrix = *pTextMatrix;
     path.m_bStroke = bStroke;
     path.m_FillType = bFill ? FXFILL_WINDING : 0;
     path.CalcBoundingBox();
     ProcessPath(&path, pObj2Device);
   }
 }