Fix an assertion failure in CFX_RTFBreak::SetLineWidth()

xfa/src/fgas/src/layout/fx_rtfbreak.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 <algorithm>
 
 #include "xfa/src/fgas/include/fx_lbk.h"
 #include "xfa/src/fgas/src/fgas_base.h"
 #include "xfa/src/fgas/src/layout/fx_unicode.h"
 #include "xfa/src/fgas/src/layout/fx_rtfbreak.h"
 
 IFX_RTFBreak* IFX_RTFBreak::Create(FX_DWORD dwPolicies) {
   return new CFX_RTFBreak(dwPolicies);
 }
 CFX_RTFBreak::CFX_RTFBreak(FX_DWORD dwPolicies)
     : m_dwPolicies(dwPolicies),
       m_pArabicChar(NULL),
-      m_iLineStart(0),
-      m_iLineEnd(2000000),
+      m_iBoundaryStart(0),
+      m_iBoundaryEnd(2000000),
       m_dwLayoutStyles(0),
       m_bPagination(FALSE),
       m_bVertical(FALSE),
       m_bSingleLine(FALSE),
       m_bCharCode(FALSE),
       m_pFont(NULL),
       m_iFontHeight(240),
       m_iFontSize(240),
       m_iTabWidth(720000),
       m_PositionedTabs(),
@@ skipping 23 matching lines @@
   m_pCurLine = &m_RTFLine1;
 }
 CFX_RTFBreak::~CFX_RTFBreak() {
   Reset();
   m_PositionedTabs.RemoveAll();
   m_pArabicChar->Release();
   if (m_pUserData != NULL) {
     m_pUserData->Release();
   }
 }
-void CFX_RTFBreak::SetLineWidth(FX_FLOAT fLineStart, FX_FLOAT fLineEnd) {
-  m_iLineStart = FXSYS_round(fLineStart * 20000.0f);
-  m_iLineEnd = FXSYS_round(fLineEnd * 20000.0f);
-  FXSYS_assert(m_iLineEnd >= m_iLineStart);
-  if (m_pCurLine->m_iStart < m_iLineStart) {
-    m_pCurLine->m_iStart = m_iLineStart;
-  }
+void CFX_RTFBreak::SetLineBoundary(FX_FLOAT fLineStart, FX_FLOAT fLineEnd) {
+  if (fLineStart > fLineEnd)
+    return;
+  m_iBoundaryStart = FXSYS_round(fLineStart * 20000.0f);
+  m_iBoundaryEnd = FXSYS_round(fLineEnd * 20000.0f);
+  m_pCurLine->m_iStart = std::min(m_pCurLine->m_iStart, m_iBoundaryEnd);
+  m_pCurLine->m_iStart = std::max(m_pCurLine->m_iStart, m_iBoundaryStart);
 }
-void CFX_RTFBreak::SetLinePos(FX_FLOAT fLinePos) {
+void CFX_RTFBreak::SetLineStartPos(FX_FLOAT fLinePos) {
   int32_t iLinePos = FXSYS_round(fLinePos * 20000.0f);
-  if (iLinePos > m_iLineEnd) {
-    iLinePos = m_iLineEnd;
-  }
+  iLinePos = std::min(iLinePos, m_iBoundaryEnd);
+  iLinePos = std::max(iLinePos, m_iBoundaryStart);
   m_pCurLine->m_iStart = iLinePos;
 }
 void CFX_RTFBreak::SetLayoutStyles(FX_DWORD dwLayoutStyles) {
   if (m_dwLayoutStyles == dwLayoutStyles) {
     return;
   }
   SetBreakStatus();
   m_dwLayoutStyles = dwLayoutStyles;
   m_bPagination = (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_Pagination) != 0;
   m_bVertical = (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_VerticalChars) != 0;
@@ skipping 34 matching lines @@
     if (m_wDefChar != 0xFEFF) {
       m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
       m_iDefChar *= m_iFontSize;
     }
   }
 }
 void CFX_RTFBreak::SetTabWidth(FX_FLOAT fTabWidth) {
   m_iTabWidth = FXSYS_round(fTabWidth * 20000.0f);
 }
 void CFX_RTFBreak::AddPositionedTab(FX_FLOAT fTabPos) {
-  int32_t iLineEnd = m_iLineEnd;
-  int32_t iTabPos = FXSYS_round(fTabPos * 20000.0f) + m_iLineStart;
+  int32_t iLineEnd = m_iBoundaryEnd;
+  int32_t iTabPos = FXSYS_round(fTabPos * 20000.0f) + m_iBoundaryStart;
   if (iTabPos > iLineEnd) {
     iTabPos = iLineEnd;
   }
   if (m_PositionedTabs.Find(iTabPos, 0) > -1) {
     return;
   }
   int32_t iCount = m_PositionedTabs.GetSize();
   int32_t iFind = 0;
   for (; iFind < iCount; iFind++) {
     if (m_PositionedTabs[iFind] > iTabPos) {
       break;
     }
   }
   m_PositionedTabs.InsertAt(iFind, iTabPos);
   if (m_dwPolicies & FX_RTFBREAKPOLICY_OrphanPositionedTab) {
     m_bOrphanLine = GetLastPositionedTab() >= iLineEnd;
   } else {
     m_bOrphanLine = FALSE;
   }
 }
 void CFX_RTFBreak::SetPositionedTabs(const CFX_FloatArray& tabs) {
   m_PositionedTabs.RemoveAll();
   int32_t iCount = tabs.GetSize();
   m_PositionedTabs.SetSize(iCount);
-  int32_t iLineEnd = m_iLineEnd;
+  int32_t iLineEnd = m_iBoundaryEnd;
   int32_t iTabPos;
   for (int32_t i = 0; i < iCount; i++) {
-    iTabPos = FXSYS_round(tabs[i] * 20000.0f) + m_iLineStart;
+    iTabPos = FXSYS_round(tabs[i] * 20000.0f) + m_iBoundaryStart;
     if (iTabPos > iLineEnd) {
       iTabPos = iLineEnd;
     }
     m_PositionedTabs[i] = iTabPos;
   }
   if (m_dwPolicies & FX_RTFBREAKPOLICY_OrphanPositionedTab) {
     m_bOrphanLine = GetLastPositionedTab() >= iLineEnd;
   } else {
     m_bOrphanLine = FALSE;
   }
@@ skipping 138 matching lines @@
     return NULL;
   }
   return &pRTFLine->m_LinePieces;
 }
 inline FX_DWORD CFX_RTFBreak::GetUnifiedCharType(FX_DWORD dwType) const {
   return dwType >= FX_CHARTYPE_ArabicAlef ? FX_CHARTYPE_Arabic : dwType;
 }
 int32_t CFX_RTFBreak::GetLastPositionedTab() const {
   int32_t iCount = m_PositionedTabs.GetSize();
   if (iCount < 1) {
-    return m_iLineStart;
+    return m_iBoundaryStart;
   }
   return m_PositionedTabs[iCount - 1];
 }
 FX_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];
       return TRUE;
     }
@@ skipping 35 matching lines @@
   pCurChar->m_iCharWidth = 0;
   pCurChar->m_dwIdentity = m_dwIdentity;
   if (m_pUserData != NULL) {
     m_pUserData->AddRef();
   }
   pCurChar->m_pUserData = m_pUserData;
   FX_DWORD dwRet1 = FX_RTFBREAK_None;
   if (dwType != FX_CHARTYPE_Combination &&
       GetUnifiedCharType(m_dwCharType) != GetUnifiedCharType(dwType)) {
     if (!m_bSingleLine && !m_bOrphanLine && m_dwCharType > 0 &&
-        m_pCurLine->GetLineEnd() > m_iLineEnd + m_iTolerance) {
+        m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
       if (m_dwCharType != FX_CHARTYPE_Space || dwType != FX_CHARTYPE_Control) {
         dwRet1 = EndBreak(FX_RTFBREAK_LineBreak);
         int32_t iCount = m_pCurLine->CountChars();
         if (iCount > 0) {
           pCurChar = m_pCurLine->m_LineChars.GetDataPtr(iCount - 1);
         }
       }
     }
   }
   int32_t iRotation = m_iRotation;
@@ skipping 35 matching lines @@
     if (!m_pFont->GetCharWidth(wch, iCharWidth, TRUE)) {
       iCharWidth = m_iDefChar;
     }
   }
   iCharWidth *= m_iFontSize;
   iCharWidth = iCharWidth * m_iHorizontalScale / 100;
   iCharWidth += m_iCharSpace;
   pCurChar->m_iCharWidth = iCharWidth;
   m_pCurLine->m_iWidth += iCharWidth;
   m_dwCharType = 0;
-  if (!m_bSingleLine && m_pCurLine->GetLineEnd() > m_iLineEnd + m_iTolerance) {
+  if (!m_bSingleLine &&
+      m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
     return EndBreak(FX_RTFBREAK_LineBreak);
   }
   return FX_RTFBREAK_None;
 }
 FX_DWORD CFX_RTFBreak::AppendChar_Combination(CFX_RTFChar* pCurChar,
                                               int32_t iRotation) {
   int32_t iCharWidth = 0;
   if (m_bVertical != FX_IsOdd(iRotation)) {
     iCharWidth = 1000;
   } else {
@@ skipping 14 matching lines @@
   if (iCharWidth > 0) {
     m_pCurLine->m_iWidth += iCharWidth;
   }
   return FX_RTFBREAK_None;
 }
 FX_DWORD CFX_RTFBreak::AppendChar_Tab(CFX_RTFChar* pCurChar,
                                       int32_t iRotation) {
   if (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_ExpandTab) {
     FX_BOOL bBreak = FALSE;
     if ((m_dwPolicies & FX_RTFBREAKPOLICY_TabBreak) != 0) {
-      bBreak = (m_pCurLine->GetLineEnd() > m_iLineEnd + m_iTolerance);
+      bBreak = (m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance);
     }
     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;
@@ skipping 76 matching lines @@
                                  m_bCharCode)) {
         iCharWidth = m_iDefChar;
       }
   }
   iCharWidth *= m_iFontSize;
   iCharWidth = iCharWidth * m_iHorizontalScale / 100;
   pCurChar->m_iCharWidth = iCharWidth;
   iLineWidth += iCharWidth;
   m_pCurLine->m_iArabicChars++;
   if (!m_bSingleLine && !m_bOrphanLine &&
-      m_pCurLine->GetLineEnd() > m_iLineEnd + m_iTolerance) {
+      m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
     return EndBreak(FX_RTFBREAK_LineBreak);
   }
   return FX_RTFBREAK_None;
 }
 FX_DWORD CFX_RTFBreak::AppendChar_Others(CFX_RTFChar* pCurChar,
                                          int32_t iRotation) {
   FX_DWORD dwType = (pCurChar->m_dwCharProps & FX_CHARTYPEBITSMASK);
   FX_WCHAR wForm;
   if (dwType == FX_CHARTYPE_Numeric) {
     if (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_ArabicNumber) {
@@ skipping 19 matching lines @@
   iCharWidth = iCharWidth * m_iHorizontalScale / 100;
   iCharWidth += m_iCharSpace;
   if (dwType == FX_CHARTYPE_Space && m_bWordSpace) {
     iCharWidth += m_iWordSpace;
   }
   pCurChar->m_iCharWidth = iCharWidth;
   m_pCurLine->m_iWidth += iCharWidth;
   FX_BOOL bBreak = (dwType != FX_CHARTYPE_Space ||
                     (m_dwPolicies & FX_RTFBREAKPOLICY_SpaceBreak) != 0);
   if (!m_bSingleLine && !m_bOrphanLine && bBreak &&
-      m_pCurLine->GetLineEnd() > m_iLineEnd + m_iTolerance) {
+      m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
     return EndBreak(FX_RTFBREAK_LineBreak);
   }
   return FX_RTFBREAK_None;
 }
 FX_DWORD CFX_RTFBreak::EndBreak(FX_DWORD dwStatus) {
   FXSYS_assert(dwStatus >= FX_RTFBREAK_PieceBreak &&
                dwStatus <= FX_RTFBREAK_PageBreak);
   m_dwIdentity++;
   CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
   int32_t iCount = pCurPieces->GetSize();
@@ skipping 40 matching lines @@
     goto EndBreak_Ret;
   }
   if (!m_bCharCode) {
     EndBreak_BidiLine(tpos, dwStatus);
   }
   if (!m_bPagination && m_iAlignment > FX_RTFLINEALIGNMENT_Left) {
     EndBreak_Alignment(tpos, bAllChars, dwStatus);
   }
 EndBreak_Ret:
   m_pCurLine = pNextLine;
-  m_pCurLine->m_iStart = m_iLineStart;
+  m_pCurLine->m_iStart = m_iBoundaryStart;
   CFX_RTFChar* pTC = GetLastChar(0);
   m_dwCharType = pTC == NULL ? 0 : pTC->GetCharType();
   return dwStatus;
 }
 FX_BOOL CFX_RTFBreak::EndBreak_SplitLine(CFX_RTFLine* pNextLine,
                                          FX_BOOL bAllChars,
                                          FX_DWORD dwStatus) {
   FX_BOOL bDone = FALSE;
   if (!m_bSingleLine && !m_bOrphanLine &&
-      m_pCurLine->GetLineEnd() > m_iLineEnd + m_iTolerance) {
+      m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
     CFX_RTFChar& tc = m_pCurLine->GetChar(m_pCurLine->CountChars() - 1);
     switch (tc.GetCharType()) {
       case FX_CHARTYPE_Tab:
         if ((m_dwPolicies & FX_RTFBREAKPOLICY_TabBreak) != 0) {
           SplitTextLine(m_pCurLine, pNextLine, !m_bPagination && bAllChars);
           bDone = TRUE;
         }
         break;
       case FX_CHARTYPE_Control:
         break;
@@ skipping 195 matching lines @@
             break;
           }
         }
       }
       j += bArabic ? 1 : -1;
     }
     if (!bAllChars && bFind) {
       break;
     }
   }
-  int32_t iOffset = m_iLineEnd - iNetWidth;
+  int32_t iOffset = m_iBoundaryEnd - iNetWidth;
   int32_t iLowerAlignment = (m_iAlignment & FX_RTFLINEALIGNMENT_LowerMask);
   int32_t iHigherAlignment = (m_iAlignment & FX_RTFLINEALIGNMENT_HigherMask);
   if (iGapChars > 0 && (iHigherAlignment == FX_RTFLINEALIGNMENT_Distributed ||
                         (iHigherAlignment == FX_RTFLINEALIGNMENT_Justified &&
                          dwStatus != FX_RTFBREAK_ParagraphBreak))) {
     int32_t iStart = -1;
     for (i = 0; i < iCount; i++) {
       tpo = tpos.GetAt(i);
       CFX_RTFPiece& ttp = pCurPieces->GetAt(tpo.index);
       if (iStart < 0) {
@@ skipping 33 matching lines @@
 int32_t CFX_RTFBreak::GetBreakPos(CFX_RTFCharArray& tca,
                                   int32_t& iEndPos,
                                   FX_BOOL bAllChars,
                                   FX_BOOL bOnlyBrk) {
   int32_t iLength = tca.GetSize() - 1;
   if (iLength < 1) {
     return iLength;
   }
   int32_t iBreak = -1, iBreakPos = -1, iIndirect = -1, iIndirectPos = -1,
           iLast = -1, iLastPos = -1;
-  if (m_bSingleLine || m_bOrphanLine || iEndPos <= m_iLineEnd) {
+  if (m_bSingleLine || m_bOrphanLine || iEndPos <= m_iBoundaryEnd) {
     if (!bAllChars || m_bCharCode) {
       return iLength;
     }
     iBreak = iLength;
     iBreakPos = iEndPos;
   }
   CFX_RTFChar* pCharArray = tca.GetData();
   if (m_bCharCode) {
     const CFX_RTFChar* pChar;
     int32_t iCharWidth;
     while (iLength > 0) {
-      if (iEndPos <= m_iLineEnd) {
+      if (iEndPos <= m_iBoundaryEnd) {
         break;
       }
       pChar = pCharArray + iLength--;
       iCharWidth = pChar->m_iCharWidth;
       if (iCharWidth > 0) {
         iEndPos -= iCharWidth;
       }
     }
     return iLength;
   }
@@ skipping 46 matching lines @@
                   (nCur << 5) + nNext);
       }
     }
     if (bAllChars) {
       pCur->m_nBreakType = eType;
     }
     if (!bOnlyBrk) {
       iCharWidth = pCur->m_iCharWidth;
       FX_BOOL bBreak = FALSE;
       if (nCur == FX_CBP_TB && bTabBreak) {
-        bBreak = iCharWidth > 0 && iEndPos - iCharWidth <= m_iLineEnd;
+        bBreak = iCharWidth > 0 && iEndPos - iCharWidth <= m_iBoundaryEnd;
       } else {
-        bBreak = iEndPos <= m_iLineEnd;
+        bBreak = iEndPos <= m_iBoundaryEnd;
       }
       if (m_bSingleLine || m_bOrphanLine || bBreak || bNeedBreak) {
         if (eType == FX_LBT_DIRECT_BRK && iBreak < 0) {
           iBreak = iLength;
           iBreakPos = iEndPos;
           if (!bAllChars) {
             return iLength;
           }
         } else if (eType == FX_LBT_INDIRECT_BRK && iIndirect < 0) {
           iIndirect = iLength;
@@ skipping 91 matching lines @@
   }
   if (index < 0 || index >= pRTFPieces->GetSize()) {
     return NULL;
   }
   return pRTFPieces->GetPtrAt(index);
 }
 void CFX_RTFBreak::GetLineRect(CFX_RectF& rect) const {
   rect.top = 0;
   CFX_RTFLine* pRTFLine = GetRTFLine(TRUE);
   if (pRTFLine == NULL) {
-    rect.left = ((FX_FLOAT)m_iLineStart) / 20000.0f;
+    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;
   int32_t iCount = rtfPieces.GetSize();
   if (iCount < 1) {
     rect.width = 0;
     return;
@@ skipping 367 matching lines @@
         rtBBoxF.height = fHeight;
         rtBBoxF.top = std::max(rtBBoxF.top, 0.0f);
       }
       rtArray.SetAt(i, rtBBoxF);
       continue;
     }
     rtArray.SetAt(i, rect);
   }
   return iLength;
 }