Banish CFX_WordArray to XFA-land.

core/src/fpdftext/fpdf_text_int.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/src/fpdftext/text_int.h"
 
 #include <algorithm>
 #include <cctype>
@@ skipping 126 matching lines @@
 FX_BOOL CPDF_TextPage::ParseTextPage() {
   m_bIsParsed = false;
   if (!m_pPage)
     return FALSE;
 
   m_TextBuf.Clear();
   m_CharList.clear();
   m_pPreTextObj = NULL;
   ProcessObject();
   m_bIsParsed = true;
-  m_CharIndex.RemoveAll();
+  m_CharIndex.clear();
   int nCount = pdfium::CollectionSize<int>(m_CharList);
   if (nCount) {
-    m_CharIndex.Add(0);
+    m_CharIndex.push_back(0);
   }
   for (int i = 0; i < nCount; i++) {
-    int indexSize = m_CharIndex.GetSize();
+    int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
     FX_BOOL bNormal = FALSE;
     const PAGECHAR_INFO& charinfo = m_CharList[i];
     if (charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED) {
       bNormal = TRUE;
     } else if (charinfo.m_Unicode == 0 || IsControlChar(charinfo)) {
       bNormal = FALSE;
     } else {
       bNormal = TRUE;
     }
     if (bNormal) {
       if (indexSize % 2) {
-        m_CharIndex.Add(1);
+        m_CharIndex.push_back(1);
       } else {
         if (indexSize <= 0) {
           continue;
         }
-        m_CharIndex.SetAt(indexSize - 1, m_CharIndex.GetAt(indexSize - 1) + 1);
+        m_CharIndex[indexSize - 1] += 1;
       }
     } else {
       if (indexSize % 2) {
         if (indexSize <= 0) {
           continue;
         }
-        m_CharIndex.SetAt(indexSize - 1, i + 1);
+        m_CharIndex[indexSize - 1] = i + 1;
       } else {
-        m_CharIndex.Add(i + 1);
+        m_CharIndex.push_back(i + 1);
       }
     }
   }
-  int indexSize = m_CharIndex.GetSize();
+  int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
   if (indexSize % 2) {
-    m_CharIndex.RemoveAt(indexSize - 1);
+    m_CharIndex.erase(m_CharIndex.begin() + indexSize - 1);
   }
   return TRUE;
 }
 int CPDF_TextPage::CountChars() const {
   return pdfium::CollectionSize<int>(m_CharList);
 }
 int CPDF_TextPage::CharIndexFromTextIndex(int TextIndex) const {
-  int indexSize = m_CharIndex.GetSize();
+  int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
   int count = 0;
   for (int i = 0; i < indexSize; i += 2) {
-    count += m_CharIndex.GetAt(i + 1);
-    if (count > TextIndex) {
-      return TextIndex - count + m_CharIndex.GetAt(i + 1) +
-             m_CharIndex.GetAt(i);
-    }
+    count += m_CharIndex[i + 1];
+    if (count > TextIndex)
+      return TextIndex - count + m_CharIndex[i + 1] + m_CharIndex[i];
   }
   return -1;
 }
 int CPDF_TextPage::TextIndexFromCharIndex(int CharIndex) const {
-  int indexSize = m_CharIndex.GetSize();
+  int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
   int count = 0;
   for (int i = 0; i < indexSize; i += 2) {
-    count += m_CharIndex.GetAt(i + 1);
-    if (m_CharIndex.GetAt(i + 1) + m_CharIndex.GetAt(i) > CharIndex) {
-      if (CharIndex - m_CharIndex.GetAt(i) < 0) {
+    count += m_CharIndex[i + 1];
+    if (m_CharIndex[i + 1] + m_CharIndex[i] > CharIndex) {
+      if (CharIndex - m_CharIndex[i] < 0)
         return -1;
-      }
-      return CharIndex - m_CharIndex.GetAt(i) + count -
-             m_CharIndex.GetAt(i + 1);
+
+      return CharIndex - m_CharIndex[i] + count - m_CharIndex[i + 1];
     }
   }
   return -1;
 }
 void CPDF_TextPage::GetRectArray(int start,
                                  int nCount,
                                  CFX_RectArray& rectArray) const {
   if (start < 0 || nCount == 0) {
     return;
   }
@@ skipping 761 matching lines @@
     info.m_Index = -1;
   }
   m_CharList.push_back(info);
 }
 void CPDF_TextPage::CloseTempLine() {
   if (m_TempCharList.empty()) {
     return;
   }
   std::unique_ptr<CFX_BidiChar> pBidiChar(new CFX_BidiChar);
   CFX_WideString str = m_TempTextBuf.GetWideString();
-  CFX_WordArray order;
+  std::vector<FX_WORD> order;
   FX_BOOL bR2L = FALSE;
   int32_t start = 0, count = 0;
   int nR2L = 0, nL2R = 0;
   FX_BOOL bPrevSpace = FALSE;
   for (int i = 0; i < str.GetLength(); i++) {
     if (str.GetAt(i) == 32) {
       if (bPrevSpace) {
         m_TempTextBuf.Delete(i, 1);
         m_TempCharList.erase(m_TempCharList.begin() + i);
         str.Delete(i);
         i--;
         continue;
       }
       bPrevSpace = TRUE;
     } else {
       bPrevSpace = FALSE;
     }
     if (pBidiChar->AppendChar(str.GetAt(i))) {
       CFX_BidiChar::Direction ret = pBidiChar->GetBidiInfo(&start, &count);
-      order.Add(start);
-      order.Add(count);
-      order.Add(ret);
+      order.push_back(start);
+      order.push_back(count);
+      order.push_back(ret);
       if (!bR2L) {
         if (ret == CFX_BidiChar::RIGHT) {
           nR2L++;
         } else if (ret == CFX_BidiChar::LEFT) {
           nL2R++;
         }
       }
     }
   }
   if (pBidiChar->EndChar()) {
     CFX_BidiChar::Direction ret = pBidiChar->GetBidiInfo(&start, &count);
-    order.Add(start);
-    order.Add(count);
-    order.Add(ret);
+    order.push_back(start);
+    order.push_back(count);
+    order.push_back(ret);
     if (!bR2L) {
       if (ret == CFX_BidiChar::RIGHT) {
         nR2L++;
       } else if (ret == CFX_BidiChar::LEFT) {
         nL2R++;
       }
     }
   }
   if (nR2L > 0 && nR2L >= nL2R) {
     bR2L = TRUE;
   }
   if (m_parserflag == FPDFTEXT_RLTB || bR2L) {
-    int count = order.GetSize();
+    int count = order.size();

[Lei Zhang, 2016/02/09 00:45:21]

pdfium::CollectionSize<int>(order);

     for (int i = count - 1; i > 0; i -= 3) {
-      int ret = order.GetAt(i);
-      int start = order.GetAt(i - 2);
-      int count1 = order.GetAt(i - 1);
+      int ret = order[i];
+      int count1 = order[i - 1];
+      int start = order[i - 2];
       if (ret == 2 || ret == 0) {
         for (int j = start + count1 - 1; j >= start; j--) {
           AddCharInfoByRLDirection(str, j);
         }
       } else {
         int j = i;
         FX_BOOL bSymbol = FALSE;
-        while (j > 0 && order.GetAt(j) != 2) {
-          bSymbol = !order.GetAt(j);
+        while (j > 0 && order[j] != 2) {
+          bSymbol = !order[j];
           j -= 3;
         }
         int end = start + count1;
         int n = 0;
         if (bSymbol) {
           n = j + 6;
         } else {
           n = j + 3;
         }
         if (n >= i) {
           for (int m = start; m < end; m++) {
             AddCharInfoByLRDirection(str, m);
           }
         } else {
           j = i;
           i = n;
           for (; n <= j; n += 3) {
-            int start = order.GetAt(n - 2);
-            int count1 = order.GetAt(n - 1);
+            int start = order[n - 2];
+            int count1 = order[n - 1];
             int end = start + count1;
             for (int m = start; m < end; m++) {
               AddCharInfoByLRDirection(str, m);
             }
           }
         }
       }
     }
   } else {
-    int count = order.GetSize();
+    int count = order.size();
     FX_BOOL bL2R = FALSE;
     for (int i = 0; i < count; i += 3) {
-      int ret = order.GetAt(i + 2);
-      int start = order.GetAt(i);
-      int count1 = order.GetAt(i + 1);
+      int start = order[i];
+      int count1 = order[i + 1];
+      int ret = order[i + 2];
       if (ret == 2 || (i == 0 && ret == 0 && !bL2R)) {
         int j = i + 3;
         while (bR2L && j < count) {
-          if (order.GetAt(j + 2) == 1) {
+          if (order[j + 2] == 1)
             break;
-          } else {
-            j += 3;
-          }
+          j += 3;
         }
         if (j == 3) {
           i = -3;
           bL2R = TRUE;
           continue;
         }
         int end = pdfium::CollectionSize<int>(m_TempCharList) - 1;
         if (j < count) {
-          end = order.GetAt(j) - 1;
+          end = order[j] - 1;
         }
         i = j - 3;
         for (int n = end; n >= start; n--) {
           AddCharInfoByRLDirection(str, n);
         }
       } else {
         int end = start + count1;
         for (int n = start; n < end; n++) {
           AddCharInfoByLRDirection(str, n);
         }
       }
     }
   }
-  order.RemoveAll();
   m_TempCharList.clear();
   m_TempTextBuf.Delete(0, m_TempTextBuf.GetLength());
 }
 void CPDF_TextPage::ProcessTextObject(CPDF_TextObject* pTextObj,
                                       const CFX_Matrix& formMatrix,
                                       FX_POSITION ObjPos) {
   CFX_FloatRect re(pTextObj->m_Left, pTextObj->m_Bottom, pTextObj->m_Right,
                    pTextObj->m_Top);
   if (FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f) {
     return;
@@ skipping 894 matching lines @@
       m_findNextStart(-1),
       m_findPreStart(-1),
       m_bMatchCase(FALSE),
       m_bMatchWholeWord(FALSE),
       m_resStart(0),
       m_resEnd(-1),
       m_IsFind(FALSE) {
   m_strText = m_pTextPage->GetPageText();
   int nCount = pTextPage->CountChars();
   if (nCount) {
-    m_CharIndex.Add(0);
+    m_CharIndex.push_back(0);
   }
   for (int i = 0; i < nCount; i++) {
     FPDF_CHAR_INFO info;
     pTextPage->GetCharInfo(i, &info);
-    int indexSize = m_CharIndex.GetSize();
+    int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
     if (info.m_Flag == CHAR_NORMAL || info.m_Flag == CHAR_GENERATED) {
       if (indexSize % 2) {
-        m_CharIndex.Add(1);
+        m_CharIndex.push_back(1);
       } else {
         if (indexSize <= 0) {
           continue;
         }
-        m_CharIndex.SetAt(indexSize - 1, m_CharIndex.GetAt(indexSize - 1) + 1);
+        m_CharIndex[indexSize - 1] += 1;
       }
     } else {
       if (indexSize % 2) {
         if (indexSize <= 0) {
           continue;
         }
-        m_CharIndex.SetAt(indexSize - 1, i + 1);
+        m_CharIndex[indexSize - 1] = i + 1;
       } else {
-        m_CharIndex.Add(i + 1);
+        m_CharIndex.push_back(i + 1);
       }
     }
   }
-  int indexSize = m_CharIndex.GetSize();
+  int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
   if (indexSize % 2) {
-    m_CharIndex.RemoveAt(indexSize - 1);
+    m_CharIndex.erase(m_CharIndex.begin() + indexSize - 1);
   }
 }
 int CPDF_TextPageFind::GetCharIndex(int index) const {
   return m_pTextPage->CharIndexFromTextIndex(index);
-  int indexSize = m_CharIndex.GetSize();
-  int count = 0;
-  for (int i = 0; i < indexSize; i += 2) {
-    count += m_CharIndex.GetAt(i + 1);
-    if (count > index) {
-      return index - count + m_CharIndex.GetAt(i + 1) + m_CharIndex.GetAt(i);
-    }
-  }
-  return -1;
 }
 FX_BOOL CPDF_TextPageFind::FindFirst(const CFX_WideString& findwhat,
                                      int flags,
                                      int startPos) {
   if (!m_pTextPage) {
     return FALSE;
   }
   if (m_strText.IsEmpty() || m_bMatchCase != (flags & FPDFTEXT_MATCHCASE)) {
     m_strText = m_pTextPage->GetPageText();
   }
@@ skipping 539 matching lines @@
   if (!m_bIsParsed || index < 0 || index >= m_LinkList.GetSize()) {
     return;
   }
   CPDF_LinkExt* link = NULL;
   link = m_LinkList.GetAt(index);
   if (!link) {
     return;
   }
   m_pTextPage->GetRectArray(link->m_Start, link->m_Count, rects);
 }