Fixup RTFBreak and TextBreak nits

Change-Id: Ied5d23e18e9194e66d8be8d1057f55d83faada88
Reviewed-on: https://pdfium-review.googlesource.com/2880
Reviewed-by: Nicolás Peña <npm@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: dsinclair <dsinclair@chromium.org>

1 files changed, 305 insertions, 306 deletions

diff --git a/xfa/fgas/layout/fgas_rtfbreak.cpp b/xfa/fgas/layout/fgas_rtfbreak.cpp
index a3bf58c27b..e2cfaaaec3 100644
--- a/xfa/fgas/layout/fgas_rtfbreak.cpp
+++ b/xfa/fgas/layout/fgas_rtfbreak.cpp
@@ -15,6 +15,23 @@
 #include "xfa/fgas/layout/fgas_linebreak.h"
 #include "xfa/fgas/layout/fgas_unicode.h"
 
+namespace {
+
+typedef CFX_RTFBreakType (CFX_RTFBreak::*FX_RTFBreak_LPFAppendChar)(
+    CFX_RTFChar* pCurChar);
+const FX_RTFBreak_LPFAppendChar g_FX_RTFBreak_lpfAppendChar[16] = {
+    &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Tab,
+    &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Control,
+    &CFX_RTFBreak::AppendChar_Combination, &CFX_RTFBreak::AppendChar_Others,
+    &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Arabic,
+    &CFX_RTFBreak::AppendChar_Arabic,      &CFX_RTFBreak::AppendChar_Arabic,
+    &CFX_RTFBreak::AppendChar_Arabic,      &CFX_RTFBreak::AppendChar_Arabic,
+    &CFX_RTFBreak::AppendChar_Arabic,      &CFX_RTFBreak::AppendChar_Others,
+    &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Others,
+};
+
+}  // namespace
+
 CFX_RTFBreak::CFX_RTFBreak(uint32_t dwLayoutStyles)
     : m_iBoundaryStart(0),
       m_iBoundaryEnd(2000000),
@@ -74,31 +91,30 @@ void CFX_RTFBreak::SetFont(const CFX_RetainPtr<CFGAS_GEFont>& pFont) {
 
   SetBreakStatus();
   m_pFont = pFont;
-  m_iDefChar = 0;
-  if (m_pFont) {
-    m_iFontHeight = m_iFontSize;
-    if (m_wDefChar != 0xFEFF) {
-      m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, false);
-      m_iDefChar *= m_iFontSize;
-    }
-  }
+  FontChanged();
 }
 
 void CFX_RTFBreak::SetFontSize(FX_FLOAT fFontSize) {
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
-  if (m_iFontSize == iFontSize) {
+  if (m_iFontSize == iFontSize)
     return;
-  }
+
   SetBreakStatus();
   m_iFontSize = iFontSize;
+  FontChanged();
+}
+
+void CFX_RTFBreak::FontChanged() {
   m_iDefChar = 0;
-  if (m_pFont) {
-    m_iFontHeight = m_iFontSize;
-    if (m_wDefChar != 0xFEFF) {
-      m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, false);
-      m_iDefChar *= m_iFontSize;
-    }
-  }
+  if (!m_pFont)
+    return;
+
+  m_iFontHeight = m_iFontSize;
+  if (m_wDefChar == 0xFEFF)
+    return;
+
+  m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, false);
+  m_iDefChar *= m_iFontSize;
 }
 
 void CFX_RTFBreak::SetTabWidth(FX_FLOAT fTabWidth) {
@@ -172,32 +188,31 @@ void CFX_RTFBreak::SetBreakStatus() {
 CFX_RTFChar* CFX_RTFBreak::GetLastChar(int32_t index) const {
   std::vector<CFX_RTFChar>& tca = m_pCurLine->m_LineChars;
   int32_t iCount = pdfium::CollectionSize<int32_t>(tca);
-  if (index < 0 || index >= iCount) {
+  if (index < 0 || index >= iCount)
     return nullptr;
-  }
+
   int32_t iStart = iCount - 1;
   while (iStart > -1) {
     CFX_RTFChar* pTC = &tca[iStart--];
     if (pTC->m_iCharWidth >= 0 ||
         pTC->GetCharType() != FX_CHARTYPE_Combination) {
-      if (--index < 0) {
+      if (--index < 0)
         return pTC;
-      }
     }
   }
   return nullptr;
 }
 
-CFX_RTFLine* CFX_RTFBreak::GetRTFLine() const {
+const CFX_RTFLine* CFX_RTFBreak::GetRTFLine() const {
   if (m_iReady == 1)
-    return (CFX_RTFLine*)&m_RTFLine1;
+    return &m_RTFLine1;
   if (m_iReady == 2)
-    return (CFX_RTFLine*)&m_RTFLine2;
+    return &m_RTFLine2;
   return nullptr;
 }
 
-CFX_RTFPieceArray* CFX_RTFBreak::GetRTFPieces() const {
-  CFX_RTFLine* pRTFLine = GetRTFLine();
+const CFX_RTFPieceArray* CFX_RTFBreak::GetRTFPieces() const {
+  const CFX_RTFLine* pRTFLine = GetRTFLine();
   return pRTFLine ? &pRTFLine->m_LinePieces : nullptr;
 }
 
@@ -205,40 +220,29 @@ inline FX_CHARTYPE CFX_RTFBreak::GetUnifiedCharType(
     FX_CHARTYPE chartype) const {
   return chartype >= FX_CHARTYPE_ArabicAlef ? FX_CHARTYPE_Arabic : chartype;
 }
+
 int32_t CFX_RTFBreak::GetLastPositionedTab() const {
   int32_t iCount = m_PositionedTabs.GetSize();
-  if (iCount < 1) {
+  if (iCount < 1)
     return m_iBoundaryStart;
-  }
   return m_PositionedTabs[iCount - 1];
 }
-bool CFX_RTFBreak::GetPositionedTab(int32_t& iTabPos) const {
+
+bool CFX_RTFBreak::GetPositionedTab(int32_t* iTabPos) const {
   int32_t iCount = m_PositionedTabs.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
-    if (m_PositionedTabs[i] > iTabPos) {
-      iTabPos = m_PositionedTabs[i];
+    if (m_PositionedTabs[i] > *iTabPos) {
+      *iTabPos = m_PositionedTabs[i];
       return true;
     }
   }
   return false;
 }
-typedef CFX_RTFBreakType (CFX_RTFBreak::*FX_RTFBreak_LPFAppendChar)(
-    CFX_RTFChar* pCurChar);
-static const FX_RTFBreak_LPFAppendChar g_FX_RTFBreak_lpfAppendChar[16] = {
-    &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Tab,
-    &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Control,
-    &CFX_RTFBreak::AppendChar_Combination, &CFX_RTFBreak::AppendChar_Others,
-    &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Arabic,
-    &CFX_RTFBreak::AppendChar_Arabic,      &CFX_RTFBreak::AppendChar_Arabic,
-    &CFX_RTFBreak::AppendChar_Arabic,      &CFX_RTFBreak::AppendChar_Arabic,
-    &CFX_RTFBreak::AppendChar_Arabic,      &CFX_RTFBreak::AppendChar_Others,
-    &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Others,
-};
 
 CFX_RTFBreakType CFX_RTFBreak::AppendChar(FX_WCHAR wch) {
   ASSERT(m_pFont && m_pCurLine);
 
-  uint32_t dwProps = kTextLayoutCodeProperties[(uint16_t)wch];
+  uint32_t dwProps = kTextLayoutCodeProperties[static_cast<uint16_t>(wch)];
   FX_CHARTYPE chartype = GetCharTypeFromProp(dwProps);
   m_pCurLine->m_LineChars.emplace_back();
 
@@ -253,20 +257,19 @@ CFX_RTFBreakType CFX_RTFBreak::AppendChar(FX_WCHAR wch) {
   pCurChar->m_iCharWidth = 0;
   pCurChar->m_dwIdentity = m_dwIdentity;
   pCurChar->m_pUserData = m_pUserData;
+
   CFX_RTFBreakType dwRet1 = CFX_RTFBreakType::None;
   if (chartype != FX_CHARTYPE_Combination &&
-      GetUnifiedCharType(m_eCharType) != GetUnifiedCharType(chartype)) {
-    if (m_eCharType != FX_CHARTYPE_Unknown &&
-        m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
-      if (m_eCharType != FX_CHARTYPE_Space || chartype != FX_CHARTYPE_Control) {
-        dwRet1 = EndBreak(CFX_RTFBreakType::Line);
-        int32_t iCount = m_pCurLine->CountChars();
-        if (iCount > 0) {
-          pCurChar = &m_pCurLine->m_LineChars[iCount - 1];
-        }
-      }
-    }
+      GetUnifiedCharType(m_eCharType) != GetUnifiedCharType(chartype) &&
+      m_eCharType != FX_CHARTYPE_Unknown &&
+      m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance &&
+      (m_eCharType != FX_CHARTYPE_Space || chartype != FX_CHARTYPE_Control)) {
+    dwRet1 = EndBreak(CFX_RTFBreakType::Line);
+    int32_t iCount = m_pCurLine->CountChars();
+    if (iCount > 0)
+      pCurChar = &m_pCurLine->m_LineChars[iCount - 1];
   }
+
   CFX_RTFBreakType dwRet2 =
       (this->*g_FX_RTFBreak_lpfAppendChar[chartype >> FX_CHARTYPEBITS])(
           pCurChar);
@@ -295,17 +298,18 @@ CFX_RTFBreakType CFX_RTFBreak::AppendChar_Combination(CFX_RTFChar* pCurChar) {
 }
 
 CFX_RTFBreakType CFX_RTFBreak::AppendChar_Tab(CFX_RTFChar* pCurChar) {
-  if (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_ExpandTab) {
-    int32_t& iLineWidth = m_pCurLine->m_iWidth;
-    int32_t iCharWidth = iLineWidth;
-    if (GetPositionedTab(iCharWidth))
-      iCharWidth -= iLineWidth;
-    else
-      iCharWidth = m_iTabWidth * (iLineWidth / m_iTabWidth + 1) - iLineWidth;
+  if (!(m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_ExpandTab))
+    return CFX_RTFBreakType::None;
 
-    pCurChar->m_iCharWidth = iCharWidth;
-    iLineWidth += iCharWidth;
-  }
+  int32_t& iLineWidth = m_pCurLine->m_iWidth;
+  int32_t iCharWidth = iLineWidth;
+  if (GetPositionedTab(&iCharWidth))
+    iCharWidth -= iLineWidth;
+  else
+    iCharWidth = m_iTabWidth * (iLineWidth / m_iTabWidth + 1) - iLineWidth;
+
+  pCurChar->m_iCharWidth = iCharWidth;
+  iLineWidth += iCharWidth;
   return CFX_RTFBreakType::None;
 }
 
@@ -323,9 +327,8 @@ CFX_RTFBreakType CFX_RTFBreak::AppendChar_Control(CFX_RTFChar* pCurChar) {
       dwRet2 = CFX_RTFBreakType::Paragraph;
       break;
     default:
-      if (pCurChar->m_wCharCode == m_wLineBreakChar) {
+      if (pCurChar->m_wCharCode == m_wLineBreakChar)
         dwRet2 = CFX_RTFBreakType::Paragraph;
-      }
       break;
   }
   if (dwRet2 != CFX_RTFBreakType::None)
@@ -336,7 +339,6 @@ CFX_RTFBreakType CFX_RTFBreak::AppendChar_Control(CFX_RTFChar* pCurChar) {
 
 CFX_RTFBreakType CFX_RTFBreak::AppendChar_Arabic(CFX_RTFChar* pCurChar) {
   CFX_RTFChar* pLastChar = nullptr;
-  int32_t& iLineWidth = m_pCurLine->m_iWidth;
   int32_t iCharWidth = 0;
   FX_WCHAR wForm;
   bool bAlef = false;
@@ -344,23 +346,24 @@ CFX_RTFBreakType CFX_RTFBreak::AppendChar_Arabic(CFX_RTFChar* pCurChar) {
       m_eCharType <= FX_CHARTYPE_ArabicDistortion) {
     pLastChar = GetLastChar(1);
     if (pLastChar) {
-      iLineWidth -= pLastChar->m_iCharWidth;
+      m_pCurLine->m_iWidth -= pLastChar->m_iCharWidth;
       CFX_RTFChar* pPrevChar = GetLastChar(2);
       wForm = pdfium::arabic::GetFormChar(pLastChar, pPrevChar, pCurChar);
       bAlef = (wForm == 0xFEFF &&
                pLastChar->GetCharType() == FX_CHARTYPE_ArabicAlef);
-      if (!m_pFont->GetCharWidth(wForm, iCharWidth, false)) {
-        if (!m_pFont->GetCharWidth(pLastChar->m_wCharCode, iCharWidth, false))
-          iCharWidth = m_iDefChar;
+      if (!m_pFont->GetCharWidth(wForm, iCharWidth, false) &&
+          !m_pFont->GetCharWidth(pLastChar->m_wCharCode, iCharWidth, false)) {
+        iCharWidth = m_iDefChar;
       }
 
       iCharWidth *= m_iFontSize;
       iCharWidth = iCharWidth * m_iHorizontalScale / 100;
       pLastChar->m_iCharWidth = iCharWidth;
-      iLineWidth += iCharWidth;
+      m_pCurLine->m_iWidth += iCharWidth;
       iCharWidth = 0;
     }
   }
+
   wForm = pdfium::arabic::GetFormChar(pCurChar, bAlef ? nullptr : pLastChar,
                                       nullptr);
   if (!m_pFont->GetCharWidth(wForm, iCharWidth, false) &&
@@ -371,23 +374,17 @@ CFX_RTFBreakType CFX_RTFBreak::AppendChar_Arabic(CFX_RTFChar* pCurChar) {
   iCharWidth *= m_iFontSize;
   iCharWidth = iCharWidth * m_iHorizontalScale / 100;
   pCurChar->m_iCharWidth = iCharWidth;
-  iLineWidth += iCharWidth;
+  m_pCurLine->m_iWidth += iCharWidth;
   m_pCurLine->m_iArabicChars++;
-  if (m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
+
+  if (m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance)
     return EndBreak(CFX_RTFBreakType::Line);
-  }
   return CFX_RTFBreakType::None;
 }
 
 CFX_RTFBreakType CFX_RTFBreak::AppendChar_Others(CFX_RTFChar* pCurChar) {
   FX_CHARTYPE chartype = pCurChar->GetCharType();
-  FX_WCHAR wForm;
-  if (chartype == FX_CHARTYPE_Numeric) {
-    wForm = pCurChar->m_wCharCode;
-  } else {
-    wForm = pCurChar->m_wCharCode;
-  }
-
+  FX_WCHAR wForm = pCurChar->m_wCharCode;
   int32_t iCharWidth = 0;
   if (!m_pFont->GetCharWidth(wForm, iCharWidth, false))
     iCharWidth = m_iDefChar;
@@ -409,7 +406,7 @@ CFX_RTFBreakType CFX_RTFBreak::EndBreak(CFX_RTFBreakType dwStatus) {
   ASSERT(dwStatus != CFX_RTFBreakType::None);
 
   m_dwIdentity++;
-  CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
+  const CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
   int32_t iCount = pCurPieces->GetSize();
   if (iCount > 0) {
     CFX_RTFPiece* pLastPiece = pCurPieces->GetPtrAt(--iCount);
@@ -420,7 +417,7 @@ CFX_RTFBreakType CFX_RTFBreak::EndBreak(CFX_RTFBreakType dwStatus) {
     return dwStatus;
   }
 
-  CFX_RTFLine* pLastLine = GetRTFLine();
+  const CFX_RTFLine* pLastLine = GetRTFLine();
   if (pLastLine) {
     pCurPieces = &pLastLine->m_LinePieces;
     iCount = pCurPieces->GetSize();
@@ -444,14 +441,14 @@ CFX_RTFBreakType CFX_RTFBreak::EndBreak(CFX_RTFBreakType dwStatus) {
   if (dwStatus == CFX_RTFBreakType::Piece)
     return dwStatus;
 
-  m_iReady = (m_pCurLine == &m_RTFLine1) ? 1 : 2;
+  m_iReady = m_pCurLine == &m_RTFLine1 ? 1 : 2;
   CFX_RTFLine* pNextLine =
-      (m_pCurLine == &m_RTFLine1) ? &m_RTFLine2 : &m_RTFLine1;
+      m_pCurLine == &m_RTFLine1 ? &m_RTFLine2 : &m_RTFLine1;
   bool bAllChars = m_iAlignment == CFX_RTFLineAlignment::Justified ||
                    m_iAlignment == CFX_RTFLineAlignment::Distributed;
   CFX_TPOArray tpos(100);
   if (!EndBreak_SplitLine(pNextLine, bAllChars, dwStatus)) {
-    EndBreak_BidiLine(tpos, dwStatus);
+    EndBreak_BidiLine(&tpos, dwStatus);
 
     if (!m_bPagination && m_iAlignment != CFX_RTFLineAlignment::Left)
       EndBreak_Alignment(tpos, bAllChars, dwStatus);
@@ -459,6 +456,7 @@ CFX_RTFBreakType CFX_RTFBreak::EndBreak(CFX_RTFBreakType dwStatus) {
 
   m_pCurLine = pNextLine;
   m_pCurLine->m_iStart = m_iBoundaryStart;
+
   CFX_RTFChar* pTC = GetLastChar(0);
   m_eCharType = pTC ? pTC->GetCharType() : FX_CHARTYPE_Unknown;
   return dwStatus;
@@ -469,7 +467,7 @@ bool CFX_RTFBreak::EndBreak_SplitLine(CFX_RTFLine* pNextLine,
                                       CFX_RTFBreakType dwStatus) {
   bool bDone = false;
   if (m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
-    CFX_RTFChar& tc = m_pCurLine->GetChar(m_pCurLine->CountChars() - 1);
+    const CFX_RTFChar& tc = m_pCurLine->GetChar(m_pCurLine->CountChars() - 1);
     switch (tc.GetCharType()) {
       case FX_CHARTYPE_Tab:
       case FX_CHARTYPE_Control:
@@ -481,76 +479,79 @@ bool CFX_RTFBreak::EndBreak_SplitLine(CFX_RTFLine* pNextLine,
         break;
     }
   }
-  if (m_bPagination || m_pCurLine->m_iMBCSChars > 0) {
-    const CFX_RTFChar* pCurChars = m_pCurLine->m_LineChars.data();
-    const CFX_RTFChar* pTC;
-    CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
-    CFX_RTFPiece tp;
-    tp.m_pChars = &m_pCurLine->m_LineChars;
-    bool bNew = true;
-    uint32_t dwIdentity = (uint32_t)-1;
-    int32_t iLast = m_pCurLine->CountChars() - 1, j = 0;
-    for (int32_t i = 0; i <= iLast;) {
-      pTC = pCurChars + i;
-      if (bNew) {
-        tp.m_iStartChar = i;
-        tp.m_iStartPos += tp.m_iWidth;
-        tp.m_iWidth = 0;
+
+  if (!m_bPagination && m_pCurLine->m_iMBCSChars <= 0) {
+    if (bAllChars && !bDone) {
+      int32_t endPos = m_pCurLine->GetLineEnd();
+      GetBreakPos(m_pCurLine->m_LineChars, endPos, bAllChars, true);
+    }
+    return false;
+  }
+
+  const CFX_RTFChar* pCurChars = m_pCurLine->m_LineChars.data();
+  const CFX_RTFChar* pTC;
+  CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
+  CFX_RTFPiece tp;
+  tp.m_pChars = &m_pCurLine->m_LineChars;
+  bool bNew = true;
+  uint32_t dwIdentity = static_cast<uint32_t>(-1);
+  int32_t iLast = m_pCurLine->CountChars() - 1;
+  int32_t j = 0;
+  for (int32_t i = 0; i <= iLast;) {
+    pTC = pCurChars + i;
+    if (bNew) {
+      tp.m_iStartChar = i;
+      tp.m_iStartPos += tp.m_iWidth;
+      tp.m_iWidth = 0;
+      tp.m_dwStatus = pTC->m_dwStatus;
+      tp.m_iFontSize = pTC->m_iFontSize;
+      tp.m_iFontHeight = pTC->m_iFontHeight;
+      tp.m_iHorizontalScale = pTC->m_iHorizontalScale;
+      tp.m_iVerticalScale = pTC->m_iVerticalScale;
+      dwIdentity = pTC->m_dwIdentity;
+      tp.m_dwIdentity = dwIdentity;
+      tp.m_pUserData = pTC->m_pUserData;
+      j = i;
+      bNew = false;
+    }
+
+    if (i == iLast || pTC->m_dwStatus != CFX_RTFBreakType::None ||
+        pTC->m_dwIdentity != dwIdentity) {
+      tp.m_iChars = i - j;
+      if (pTC->m_dwIdentity == dwIdentity) {
         tp.m_dwStatus = pTC->m_dwStatus;
-        tp.m_iFontSize = pTC->m_iFontSize;
-        tp.m_iFontHeight = pTC->m_iFontHeight;
-        tp.m_iHorizontalScale = pTC->m_iHorizontalScale;
-        tp.m_iVerticalScale = pTC->m_iVerticalScale;
-        dwIdentity = pTC->m_dwIdentity;
-        tp.m_dwIdentity = dwIdentity;
-        tp.m_pUserData = pTC->m_pUserData;
-        j = i;
-        bNew = false;
-      }
-      if (i == iLast || pTC->m_dwStatus != CFX_RTFBreakType::None ||
-          pTC->m_dwIdentity != dwIdentity) {
-        tp.m_iChars = i - j;
-        if (pTC->m_dwIdentity == dwIdentity) {
-          tp.m_dwStatus = pTC->m_dwStatus;
-          tp.m_iWidth += pTC->m_iCharWidth;
-          tp.m_iChars += 1;
-          i++;
-        }
-        pCurPieces->Add(tp);
-        bNew = true;
-      } else {
         tp.m_iWidth += pTC->m_iCharWidth;
+        tp.m_iChars += 1;
         i++;
       }
+      pCurPieces->Add(tp);
+      bNew = true;
+    } else {
+      tp.m_iWidth += pTC->m_iCharWidth;
+      i++;
     }
-    return true;
-  }
-  if (bAllChars && !bDone) {
-    int32_t iEndPos = m_pCurLine->GetLineEnd();
-    GetBreakPos(m_pCurLine->m_LineChars, iEndPos, bAllChars, true);
   }
-  return false;
+  return true;
 }
-void CFX_RTFBreak::EndBreak_BidiLine(CFX_TPOArray& tpos,
+
+void CFX_RTFBreak::EndBreak_BidiLine(CFX_TPOArray* tpos,
                                      CFX_RTFBreakType dwStatus) {
   FX_TPO tpo;
   CFX_RTFPiece tp;
   CFX_RTFChar* pTC;
-  int32_t i, j;
+  int32_t i;
+  int32_t j;
   std::vector<CFX_RTFChar>& chars = m_pCurLine->m_LineChars;
   int32_t iCount = m_pCurLine->CountChars();
-  bool bDone = (!m_bPagination && m_pCurLine->m_iArabicChars > 0);
-  if (bDone) {
+  if (!m_bPagination && m_pCurLine->m_iArabicChars > 0) {
     int32_t iBidiNum = 0;
     for (i = 0; i < iCount; i++) {
       pTC = &chars[i];
       pTC->m_iBidiPos = i;
-      if (pTC->GetCharType() != FX_CHARTYPE_Control) {
+      if (pTC->GetCharType() != FX_CHARTYPE_Control)
         iBidiNum = i;
-      }
-      if (i == 0) {
+      if (i == 0)
         pTC->m_iBidiLevel = 1;
-      }
     }
     FX_BidiLine(chars, iBidiNum + 1, 0);
   } else {
@@ -561,23 +562,22 @@ void CFX_RTFBreak::EndBreak_BidiLine(CFX_TPOArray& tpos,
       pTC->m_iBidiOrder = 0;
     }
   }
+
   tp.m_dwStatus = CFX_RTFBreakType::Piece;
   tp.m_iStartPos = m_pCurLine->m_iStart;
   tp.m_pChars = &chars;
   CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
-  int32_t iBidiLevel = -1, iCharWidth;
-  uint32_t dwIdentity = (uint32_t)-1;
-  i = j = 0;
+  int32_t iBidiLevel = -1;
+  int32_t iCharWidth;
+  uint32_t dwIdentity = static_cast<uint32_t>(-1);
+  i = 0;
+  j = 0;
   while (i < iCount) {
     pTC = &chars[i];
     if (iBidiLevel < 0) {
       iBidiLevel = pTC->m_iBidiLevel;
       iCharWidth = pTC->m_iCharWidth;
-      if (iCharWidth < 1) {
-        tp.m_iWidth = 0;
-      } else {
-        tp.m_iWidth = iCharWidth;
-      }
+      tp.m_iWidth = iCharWidth < 1 ? 0 : iCharWidth;
       tp.m_iBidiLevel = iBidiLevel;
       tp.m_iBidiPos = pTC->m_iBidiOrder;
       tp.m_iFontSize = pTC->m_iFontSize;
@@ -597,82 +597,83 @@ void CFX_RTFBreak::EndBreak_BidiLine(CFX_TPOArray& tpos,
       tp.m_iStartChar = i;
       tpo.index = j++;
       tpo.pos = tp.m_iBidiPos;
-      tpos.Add(tpo);
+      tpos->Add(tpo);
       iBidiLevel = -1;
     } else {
       iCharWidth = pTC->m_iCharWidth;
-      if (iCharWidth > 0) {
+      if (iCharWidth > 0)
         tp.m_iWidth += iCharWidth;
-      }
       i++;
     }
   }
+
   if (i > tp.m_iStartChar) {
     tp.m_dwStatus = dwStatus;
     tp.m_iChars = i - tp.m_iStartChar;
     pCurPieces->Add(tp);
     tpo.index = j;
     tpo.pos = tp.m_iBidiPos;
-    tpos.Add(tpo);
+    tpos->Add(tpo);
   }
 
-  j = tpos.GetSize() - 1;
-  FX_TEXTLAYOUT_PieceSort(tpos, 0, j);
+  j = tpos->GetSize() - 1;
+  FX_TEXTLAYOUT_PieceSort(*tpos, 0, j);
   int32_t iStartPos = m_pCurLine->m_iStart;
   for (i = 0; i <= j; i++) {
-    tpo = tpos.GetAt(i);
+    tpo = tpos->GetAt(i);
     CFX_RTFPiece& ttp = pCurPieces->GetAt(tpo.index);
     ttp.m_iStartPos = iStartPos;
     iStartPos += ttp.m_iWidth;
   }
 }
 
-void CFX_RTFBreak::EndBreak_Alignment(CFX_TPOArray& tpos,
+void CFX_RTFBreak::EndBreak_Alignment(const CFX_TPOArray& tpos,
                                       bool bAllChars,
                                       CFX_RTFBreakType dwStatus) {
   CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
-  int32_t iNetWidth = m_pCurLine->m_iWidth, iGapChars = 0, iCharWidth;
+  int32_t iNetWidth = m_pCurLine->m_iWidth;
+  int32_t iGapChars = 0;
+  int32_t iCharWidth;
   int32_t iCount = pCurPieces->GetSize();
   bool bFind = false;
   uint32_t dwCharType;
-  int32_t i, j;
+  int32_t i;
+  int32_t j;
   FX_TPO tpo;
   for (i = iCount - 1; i > -1; i--) {
     tpo = tpos.GetAt(i);
     CFX_RTFPiece& ttp = pCurPieces->GetAt(tpo.index);
-    if (!bFind) {
+    if (!bFind)
       iNetWidth = ttp.GetEndPos();
-    }
+
     bool bArabic = FX_IsOdd(ttp.m_iBidiLevel);
     j = bArabic ? 0 : ttp.m_iChars - 1;
     while (j > -1 && j < ttp.m_iChars) {
       const CFX_RTFChar& tc = ttp.GetChar(j);
-      if (tc.m_nBreakType == FX_LBT_DIRECT_BRK) {
+      if (tc.m_nBreakType == FX_LBT_DIRECT_BRK)
         iGapChars++;
-      }
+
       if (!bFind || !bAllChars) {
         dwCharType = tc.GetCharType();
         if (dwCharType == FX_CHARTYPE_Space ||
             dwCharType == FX_CHARTYPE_Control) {
           if (!bFind) {
             iCharWidth = tc.m_iCharWidth;
-            if (bAllChars && iCharWidth > 0) {
+            if (bAllChars && iCharWidth > 0)
               iNetWidth -= iCharWidth;
-            }
           }
         } else {
           bFind = true;
-          if (!bAllChars) {
+          if (!bAllChars)
             break;
-          }
         }
       }
       j += bArabic ? 1 : -1;
     }
-    if (!bAllChars && bFind) {
+    if (!bAllChars && bFind)
       break;
-    }
   }
+
   int32_t iOffset = m_iBoundaryEnd - iNetWidth;
   if (iGapChars > 0 && (m_iAlignment == CFX_RTFLineAlignment::Distributed ||
                         (m_iAlignment == CFX_RTFLineAlignment::Justified &&
@@ -681,25 +682,23 @@ void CFX_RTFBreak::EndBreak_Alignment(CFX_TPOArray& tpos,
     for (i = 0; i < iCount; i++) {
       tpo = tpos.GetAt(i);
       CFX_RTFPiece& ttp = pCurPieces->GetAt(tpo.index);
-      if (iStart < 0) {
+      if (iStart < 0)
         iStart = ttp.m_iStartPos;
-      } else {
+      else
         ttp.m_iStartPos = iStart;
-      }
-      int32_t k;
+
       for (j = 0; j < ttp.m_iChars; j++) {
         CFX_RTFChar& tc = ttp.GetChar(j);
-        if (tc.m_nBreakType != FX_LBT_DIRECT_BRK || tc.m_iCharWidth < 0) {
+        if (tc.m_nBreakType != FX_LBT_DIRECT_BRK || tc.m_iCharWidth < 0)
           continue;
-        }
-        k = iOffset / iGapChars;
+
+        int32_t k = iOffset / iGapChars;
         tc.m_iCharWidth += k;
         ttp.m_iWidth += k;
         iOffset -= k;
         iGapChars--;
-        if (iGapChars < 1) {
+        if (iGapChars < 1)
           break;
-        }
       }
       iStart += ttp.m_iWidth;
     }
@@ -739,7 +738,8 @@ int32_t CFX_RTFBreak::GetBreakPos(std::vector<CFX_RTFChar>& tca,
   }
 
   CFX_RTFChar* pCharArray = tca.data();
-  CFX_RTFChar* pCur = pCharArray + iLength--;
+  CFX_RTFChar* pCur = pCharArray + iLength;
+  iLength--;
   if (bAllChars)
     pCur->m_nBreakType = FX_LBT_UNKNOWN;
 
@@ -755,15 +755,14 @@ int32_t CFX_RTFBreak::GetBreakPos(std::vector<CFX_RTFChar>& tca,
     uint32_t nCur = nCodeProp & 0x003F;
     bool bNeedBreak = false;
     FX_LINEBREAKTYPE eType;
-    if (nCur == FX_CBP_SP) {
-      bNeedBreak = true;
-      eType = nNext == FX_CBP_SP ? FX_LBT_PROHIBITED_BRK
-                                 : gs_FX_LineBreak_PairTable[nCur][nNext];
-    } else if (nCur == FX_CBP_TB) {
+    if (nCur == FX_CBP_TB) {
       bNeedBreak = true;
       eType = nNext == FX_CBP_TB ? FX_LBT_PROHIBITED_BRK
                                  : gs_FX_LineBreak_PairTable[nCur][nNext];
     } else {
+      if (nCur == FX_CBP_SP)
+        bNeedBreak = true;
+
       eType = nNext == FX_CBP_SP ? FX_LBT_PROHIBITED_BRK
                                  : gs_FX_LineBreak_PairTable[nCur][nNext];
     }
@@ -816,15 +815,15 @@ void CFX_RTFBreak::SplitTextLine(CFX_RTFLine* pCurLine,
                                  bool bAllChars) {
   ASSERT(pCurLine && pNextLine);
   int32_t iCount = pCurLine->CountChars();
-  if (iCount < 2) {
+  if (iCount < 2)
     return;
-  }
+
   int32_t iEndPos = pCurLine->GetLineEnd();
   std::vector<CFX_RTFChar>& curChars = pCurLine->m_LineChars;
   int32_t iCharPos = GetBreakPos(curChars, iEndPos, bAllChars, false);
-  if (iCharPos < 0) {
+  if (iCharPos < 0)
     iCharPos = 0;
-  }
+
   iCharPos++;
   if (iCharPos >= iCount) {
     pNextLine->RemoveAll(true);
@@ -832,94 +831,93 @@ void CFX_RTFBreak::SplitTextLine(CFX_RTFLine* pCurLine,
     pTC->m_nBreakType = FX_LBT_UNKNOWN;
     return;
   }
-  std::vector<CFX_RTFChar>& nextChars = pNextLine->m_LineChars;
-  nextChars =
+
+  pNextLine->m_LineChars =
       std::vector<CFX_RTFChar>(curChars.begin() + iCharPos, curChars.end());
   curChars.erase(curChars.begin() + iCharPos, curChars.end());
   pNextLine->m_iStart = pCurLine->m_iStart;
   pNextLine->m_iWidth = pCurLine->GetLineEnd() - iEndPos;
   pCurLine->m_iWidth = iEndPos;
   curChars[iCharPos - 1].m_nBreakType = FX_LBT_UNKNOWN;
-  iCount = pdfium::CollectionSize<int>(nextChars);
-  CFX_RTFChar* pNextChars = nextChars.data();
-  for (int32_t i = 0; i < iCount; i++) {
-    CFX_RTFChar* tc = pNextChars + i;
-    if (tc->GetCharType() >= FX_CHARTYPE_ArabicAlef) {
+
+  for (size_t i = 0; i < pNextLine->m_LineChars.size(); i++) {
+    if (pNextLine->m_LineChars[i].GetCharType() >= FX_CHARTYPE_ArabicAlef) {
       pCurLine->m_iArabicChars--;
       pNextLine->m_iArabicChars++;
     }
-    tc->m_dwStatus = CFX_RTFBreakType::None;
+    pNextLine->m_LineChars[i].m_dwStatus = CFX_RTFBreakType::None;
   }
 }
 
 int32_t CFX_RTFBreak::CountBreakPieces() const {
-  CFX_RTFPieceArray* pRTFPieces = GetRTFPieces();
+  const CFX_RTFPieceArray* pRTFPieces = GetRTFPieces();
   return pRTFPieces ? pRTFPieces->GetSize() : 0;
 }
 
 const CFX_RTFPiece* CFX_RTFBreak::GetBreakPiece(int32_t index) const {
-  CFX_RTFPieceArray* pRTFPieces = GetRTFPieces();
+  const CFX_RTFPieceArray* pRTFPieces = GetRTFPieces();
   if (!pRTFPieces)
     return nullptr;
-
   if (index < 0 || index >= pRTFPieces->GetSize())
     return nullptr;
-
   return pRTFPieces->GetPtrAt(index);
 }
 
 void CFX_RTFBreak::GetLineRect(CFX_RectF& rect) const {
   rect.top = 0;
-  CFX_RTFLine* pRTFLine = GetRTFLine();
+  const CFX_RTFLine* pRTFLine = GetRTFLine();
   if (!pRTFLine) {
     rect.left = ((FX_FLOAT)m_iBoundaryStart) / 20000.0f;
     rect.width = rect.height = 0;
     return;
   }
-  rect.left = ((FX_FLOAT)pRTFLine->m_iStart) / 20000.0f;
-  rect.width = ((FX_FLOAT)pRTFLine->m_iWidth) / 20000.0f;
-  CFX_RTFPieceArray& rtfPieces = pRTFLine->m_LinePieces;
+
+  rect.left = static_cast<FX_FLOAT>(pRTFLine->m_iStart) / 20000.0f;
+  rect.width = static_cast<FX_FLOAT>(pRTFLine->m_iWidth) / 20000.0f;
+  const CFX_RTFPieceArray& rtfPieces = pRTFLine->m_LinePieces;
   int32_t iCount = rtfPieces.GetSize();
   if (iCount < 1) {
     rect.width = 0;
     return;
   }
+
   CFX_RTFPiece* pBreakPiece;
-  int32_t iLineHeight = 0, iMax;
+  int32_t iLineHeight = 0;
+  int32_t iMax;
   for (int32_t i = 0; i < iCount; i++) {
     pBreakPiece = rtfPieces.GetPtrAt(i);
     int32_t iFontHeight = FXSYS_round(pBreakPiece->m_iFontHeight *
                                       pBreakPiece->m_iVerticalScale / 100.0f);
     iMax = std::max(pBreakPiece->m_iFontSize, iFontHeight);
-    if (i == 0) {
-      iLineHeight = iMax;
-    } else if (iLineHeight < iMax) {
+    if (i == 0 || iLineHeight < iMax)
       iLineHeight = iMax;
-    }
   }
-  rect.height = ((FX_FLOAT)iLineHeight) / 20.0f;
+  rect.height = static_cast<FX_FLOAT>(iLineHeight) / 20.0f;
 }
+
 void CFX_RTFBreak::ClearBreakPieces() {
-  CFX_RTFLine* pRTFLine = GetRTFLine();
-  if (pRTFLine) {
-    pRTFLine->RemoveAll(true);
-  }
+  const CFX_RTFLine* pRTFLine = GetRTFLine();
+  if (pRTFLine)
+    const_cast<CFX_RTFLine*>(pRTFLine)->RemoveAll(true);
   m_iReady = 0;
 }
+
 void CFX_RTFBreak::Reset() {
   m_eCharType = FX_CHARTYPE_Unknown;
   m_RTFLine1.RemoveAll(true);
   m_RTFLine2.RemoveAll(true);
 }
+
 int32_t CFX_RTFBreak::GetDisplayPos(const FX_RTFTEXTOBJ* pText,
                                     FXTEXT_CHARPOS* pCharPos,
                                     bool bCharCode,
                                     CFX_WideString* pWSForms,
                                     FX_AdjustCharDisplayPos pAdjustPos) const {
-  if (!pText || pText->iLength < 1) {
+  if (!pText || pText->iLength < 1)
     return 0;
-  }
+
   ASSERT(pText->pStr && pText->pWidths && pText->pFont && pText->pRect);
+
   const FX_WCHAR* pStr = pText->pStr;
   int32_t* pWidths = pText->pWidths;
   int32_t iLength = pText->iLength - 1;
@@ -932,16 +930,25 @@ int32_t CFX_RTFBreak::GetDisplayPos(const FX_RTFTEXTOBJ* pText,
   int32_t iDescent = pFont->GetDescent();
   int32_t iMaxHeight = iAscent - iDescent;
   FX_FLOAT fFontHeight = fFontSize;
-  FX_FLOAT fAscent = fFontHeight * (FX_FLOAT)iAscent / (FX_FLOAT)iMaxHeight;
-  FX_WCHAR wch, wPrev = 0xFEFF, wNext, wForm;
-  int32_t iWidth, iCharWidth, iCharHeight;
-  FX_FLOAT fX, fY, fCharWidth, fCharHeight;
+  FX_FLOAT fAscent = fFontHeight * static_cast<FX_FLOAT>(iAscent) /
+                     static_cast<FX_FLOAT>(iMaxHeight);
+  FX_WCHAR wch;
+  FX_WCHAR wPrev = 0xFEFF;
+  FX_WCHAR wNext;
+  FX_WCHAR wForm;
+  int32_t iWidth;
+  int32_t iCharWidth;
+  int32_t iCharHeight;
+  FX_FLOAT fX = rtText.left;
+  FX_FLOAT fY = rtText.top;
+  FX_FLOAT fCharWidth;
+  FX_FLOAT fCharHeight;
   int32_t iHorScale = pText->iHorizontalScale;
   int32_t iVerScale = pText->iVerticalScale;
   bool bEmptyChar;
-  uint32_t dwProps, dwCharType;
-  fX = rtText.left;
-  fY = rtText.top;
+  uint32_t dwProps;
+  uint32_t dwCharType;
+
   if (bRTLPiece)
     fX = rtText.right();
 
@@ -956,98 +963,90 @@ int32_t CFX_RTFBreak::GetDisplayPos(const FX_RTFTEXTOBJ* pText,
       wPrev = 0xFEFF;
       continue;
     }
-    if (iWidth != 0) {
-      iCharWidth = iWidth;
-      if (iCharWidth < 0)
-        iCharWidth = -iCharWidth;
-
-      bEmptyChar =
-          (dwCharType >= FX_CHARTYPE_Tab && dwCharType <= FX_CHARTYPE_Control);
-      if (!bEmptyChar)
-        iCount++;
-
-      if (pCharPos) {
-        iCharWidth /= iFontSize;
-        wForm = wch;
-        if (dwCharType >= FX_CHARTYPE_ArabicAlef) {
-          if (i < iLength) {
-            wNext = *pStr;
-            if (*pWidths < 0) {
-              if (i + 1 < iLength) {
-                wNext = pStr[1];
-              }
-            }
-          } else {
-            wNext = 0xFEFF;
-          }
-          wForm = pdfium::arabic::GetFormChar(wch, wPrev, wNext);
-        } else if (bRTLPiece) {
-          wForm = FX_GetMirrorChar(wch, dwProps, bRTLPiece, false);
+    if (iWidth == 0)
+      continue;
+
+    iCharWidth = FXSYS_abs(iWidth);
+    bEmptyChar =
+        (dwCharType >= FX_CHARTYPE_Tab && dwCharType <= FX_CHARTYPE_Control);
+    if (!bEmptyChar)
+      iCount++;
+
+    if (pCharPos) {
+      iCharWidth /= iFontSize;
+      wForm = wch;
+      if (dwCharType >= FX_CHARTYPE_ArabicAlef) {
+        if (i < iLength) {
+          wNext = *pStr;
+          if (*pWidths < 0 && i + 1 < iLength)
+            wNext = pStr[1];
+        } else {
+          wNext = 0xFEFF;
+        }
+        wForm = pdfium::arabic::GetFormChar(wch, wPrev, wNext);
+      } else if (bRTLPiece) {
+        wForm = FX_GetMirrorChar(wch, dwProps, bRTLPiece, false);
+      }
+      dwProps = FX_GetUnicodeProperties(wForm);
+
+      if (!bEmptyChar) {
+        if (bCharCode) {
+          pCharPos->m_GlyphIndex = wch;
+        } else {
+          pCharPos->m_GlyphIndex = pFont->GetGlyphIndex(wForm, false);
+          if (pCharPos->m_GlyphIndex == 0xFFFF)
+            pCharPos->m_GlyphIndex = pFont->GetGlyphIndex(wch, false);
         }
-        dwProps = FX_GetUnicodeProperties(wForm);
-
-        if (!bEmptyChar) {
-          if (bCharCode) {
-            pCharPos->m_GlyphIndex = wch;
-          } else {
-            pCharPos->m_GlyphIndex = pFont->GetGlyphIndex(wForm, false);
-            if (pCharPos->m_GlyphIndex == 0xFFFF) {
-              pCharPos->m_GlyphIndex = pFont->GetGlyphIndex(wch, false);
-            }
-          }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
-          pCharPos->m_ExtGID = pCharPos->m_GlyphIndex;
+        pCharPos->m_ExtGID = pCharPos->m_GlyphIndex;
 #endif
-          pCharPos->m_FontCharWidth = iCharWidth;
-          if (pWSForms) {
-            *pWSForms += wForm;
-          }
-        }
-        iCharHeight = 1000;
-
-        fCharWidth = fFontSize * iCharWidth / 1000.0f;
-        fCharHeight = fFontSize * iCharHeight / 1000.0f;
-        if (bRTLPiece && dwCharType != FX_CHARTYPE_Combination)
-          fX -= fCharWidth;
-
-        if (!bEmptyChar) {
-          CFX_PointF ptOffset;
-          bool bAdjusted = false;
-          if (pAdjustPos) {
-            bAdjusted =
-                pAdjustPos(wForm, false, pFont, fFontSize, false, ptOffset);
-          }
-          pCharPos->m_Origin = CFX_PointF(fX + ptOffset.x, fY - ptOffset.y);
+        pCharPos->m_FontCharWidth = iCharWidth;
+        if (pWSForms)
+          *pWSForms += wForm;
+      }
+      iCharHeight = 1000;
+
+      fCharWidth = fFontSize * iCharWidth / 1000.0f;
+      fCharHeight = fFontSize * iCharHeight / 1000.0f;
+      if (bRTLPiece && dwCharType != FX_CHARTYPE_Combination)
+        fX -= fCharWidth;
+
+      if (!bEmptyChar) {
+        CFX_PointF ptOffset;
+        bool bAdjusted = false;
+        if (pAdjustPos) {
+          bAdjusted =
+              pAdjustPos(wForm, false, pFont, fFontSize, false, ptOffset);
         }
-        if (!bRTLPiece && dwCharType != FX_CHARTYPE_Combination)
-          fX += fCharWidth;
-
-        if (!bEmptyChar) {
-          pCharPos->m_bGlyphAdjust = true;
-          pCharPos->m_AdjustMatrix[0] = -1;
-          pCharPos->m_AdjustMatrix[1] = 0;
-          pCharPos->m_AdjustMatrix[2] = 0;
-          pCharPos->m_AdjustMatrix[3] = 1;
-          pCharPos->m_Origin.y += fAscent * iVerScale / 100.0f;
-          pCharPos->m_Origin.y -= fAscent;
-
-          if (iHorScale != 100 || iVerScale != 100) {
-            pCharPos->m_AdjustMatrix[0] =
-                pCharPos->m_AdjustMatrix[0] * iHorScale / 100.0f;
-            pCharPos->m_AdjustMatrix[1] =
-                pCharPos->m_AdjustMatrix[1] * iHorScale / 100.0f;
-            pCharPos->m_AdjustMatrix[2] =
-                pCharPos->m_AdjustMatrix[2] * iVerScale / 100.0f;
-            pCharPos->m_AdjustMatrix[3] =
-                pCharPos->m_AdjustMatrix[3] * iVerScale / 100.0f;
-          }
-          pCharPos++;
+        pCharPos->m_Origin = CFX_PointF(fX + ptOffset.x, fY - ptOffset.y);
+      }
+      if (!bRTLPiece && dwCharType != FX_CHARTYPE_Combination)
+        fX += fCharWidth;
+
+      if (!bEmptyChar) {
+        pCharPos->m_bGlyphAdjust = true;
+        pCharPos->m_AdjustMatrix[0] = -1;
+        pCharPos->m_AdjustMatrix[1] = 0;
+        pCharPos->m_AdjustMatrix[2] = 0;
+        pCharPos->m_AdjustMatrix[3] = 1;
+        pCharPos->m_Origin.y += fAscent * iVerScale / 100.0f;
+        pCharPos->m_Origin.y -= fAscent;
+
+        if (iHorScale != 100 || iVerScale != 100) {
+          pCharPos->m_AdjustMatrix[0] =
+              pCharPos->m_AdjustMatrix[0] * iHorScale / 100.0f;
+          pCharPos->m_AdjustMatrix[1] =
+              pCharPos->m_AdjustMatrix[1] * iHorScale / 100.0f;
+          pCharPos->m_AdjustMatrix[2] =
+              pCharPos->m_AdjustMatrix[2] * iVerScale / 100.0f;
+          pCharPos->m_AdjustMatrix[3] =
+              pCharPos->m_AdjustMatrix[3] * iVerScale / 100.0f;
         }
+        pCharPos++;
       }
     }
-    if (iWidth > 0) {
+    if (iWidth > 0)
       wPrev = wch;
-    }
   }
   return iCount;
 }