Split CPDF_PageObjectHolder off from CPDF_PageObjectList

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 90 matching lines @@
 #define TEXT_BLANK_CHAR L' '
 #define TEXT_LINEFEED_CHAR L'\n'
 #define TEXT_RETURN_CHAR L'\r'
 #define TEXT_EMPTY L""
 #define TEXT_BLANK L" "
 #define TEXT_RETURN_LINEFEED L"\r\n"
 #define TEXT_LINEFEED L"\n"
 #define TEXT_CHARRATIO_GAPDELTA 0.070
 
 CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, int flags)
-    : m_pPage(pPage),
+    : m_pPageObjectHolder(pPage),
       m_parserflag(flags),
       m_pPreTextObj(nullptr),
       m_bIsParsed(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0) {
   m_TextBuf.EstimateSize(0, 10240);
   pPage->GetDisplayMatrix(m_DisplayMatrix, 0, 0, (int)pPage->GetPageWidth(),
                           (int)pPage->GetPageHeight(), 0);
 }
 
 bool CPDF_TextPage::IsControlChar(const PAGECHAR_INFO& charInfo) {
   switch (charInfo.m_Unicode) {
     case 0x2:
     case 0x3:
     case 0x93:
     case 0x94:
     case 0x96:
     case 0x97:
     case 0x98:
     case 0xfffe:
       return charInfo.m_Flag != FPDFTEXT_CHAR_HYPHEN;
     default:
       return false;
   }
 }
 
 FX_BOOL CPDF_TextPage::ParseTextPage() {
   m_bIsParsed = false;
-  if (!m_pPage)
+  if (!m_pPageObjectHolder)
     return FALSE;
 
   m_TextBuf.Clear();
   m_CharList.clear();
   m_pPreTextObj = NULL;
   ProcessObject();
   m_bIsParsed = true;
   m_CharIndex.clear();
   int nCount = pdfium::CollectionSize<int>(m_CharList);
   if (nCount) {
@@ skipping 598 matching lines @@
   } else if (direction == FPDFTEXT_RIGHT) {
     while (++breakPos < pdfium::CollectionSize<int>(m_CharList)) {
       if (!IsLetter(m_CharList[breakPos].m_Unicode))
         break;
     }
   }
   return breakPos;
 }
 
 int32_t CPDF_TextPage::FindTextlineFlowDirection() {
-  if (!m_pPage) {
+  if (!m_pPageObjectHolder) {
     return -1;
   }
-  const int32_t nPageWidth = (int32_t)((CPDF_Page*)m_pPage)->GetPageWidth();
-  const int32_t nPageHeight = (int32_t)((CPDF_Page*)m_pPage)->GetPageHeight();
+  const int32_t nPageWidth = static_cast<int32_t>(
+      static_cast<const CPDF_Page*>(m_pPageObjectHolder)->GetPageWidth());
+  const int32_t nPageHeight = static_cast<int32_t>(
+      static_cast<const CPDF_Page*>(m_pPageObjectHolder)->GetPageHeight());
   std::vector<uint8_t> nHorizontalMask(nPageWidth);
   std::vector<uint8_t> nVerticalMask(nPageHeight);
   uint8_t* pDataH = nHorizontalMask.data();
   uint8_t* pDataV = nVerticalMask.data();
   int32_t index = 0;
   FX_FLOAT fLineHeight = 0.0f;
   CPDF_PageObject* pPageObj = NULL;
   FX_POSITION pos = NULL;
-  pos = m_pPage->GetFirstObjectPosition();
+  pos = m_pPageObjectHolder->GetPageObjectList()->GetHeadPosition();
   if (!pos) {
     return -1;
   }
   while (pos) {
-    pPageObj = m_pPage->GetNextObject(pos);
+    pPageObj = m_pPageObjectHolder->GetPageObjectList()->GetNextObject(pos);
     if (NULL == pPageObj) {
       continue;
     }
     if (CPDF_PageObject::TEXT != pPageObj->m_Type) {
       continue;
     }
     int32_t minH =
         (int32_t)pPageObj->m_Left < 0 ? 0 : (int32_t)pPageObj->m_Left;
     int32_t maxH = (int32_t)pPageObj->m_Right > nPageWidth
                        ? nPageWidth
@@ skipping 60 matching lines @@
     return 0;
   }
   if (nSumV - nSumH > 0.0f) {
     return 1;
   }
   return -1;
 }
 
 void CPDF_TextPage::ProcessObject() {
   CPDF_PageObject* pPageObj = NULL;
-  if (!m_pPage) {
+  if (!m_pPageObjectHolder) {
     return;
   }
   FX_POSITION pos;
-  pos = m_pPage->GetFirstObjectPosition();
+  pos = m_pPageObjectHolder->GetPageObjectList()->GetHeadPosition();
   if (!pos) {
     return;
   }
   m_TextlineDir = FindTextlineFlowDirection();
   int nCount = 0;
   while (pos) {
-    pPageObj = m_pPage->GetNextObject(pos);
+    pPageObj = m_pPageObjectHolder->GetPageObjectList()->GetNextObject(pos);
     if (pPageObj) {
       if (pPageObj->m_Type == CPDF_PageObject::TEXT) {
         CFX_Matrix matrix;
         ProcessTextObject((CPDF_TextObject*)pPageObj, matrix, pos);
         nCount++;
       } else if (pPageObj->m_Type == CPDF_PageObject::FORM) {
         CFX_Matrix formMatrix(1, 0, 0, 1, 0, 0);
         ProcessFormObject((CPDF_FormObject*)pPageObj, formMatrix);
       }
     }
     pPageObj = NULL;
   }
   int count = m_LineObj.GetSize();
   for (int i = 0; i < count; i++) {
     ProcessTextObject(m_LineObj.GetAt(i));
   }
   m_LineObj.RemoveAll();
   CloseTempLine();
 }
 
 void CPDF_TextPage::ProcessFormObject(CPDF_FormObject* pFormObj,
                                       const CFX_Matrix& formMatrix) {
   CPDF_PageObject* pPageObj = NULL;
   FX_POSITION pos;
   if (!pFormObj) {
     return;
   }
-  pos = pFormObj->m_pForm->GetFirstObjectPosition();
+  pos = pFormObj->m_pForm->GetPageObjectList()->GetHeadPosition();
   if (!pos) {
     return;
   }
   CFX_Matrix curFormMatrix;
   curFormMatrix.Copy(pFormObj->m_FormMatrix);
   curFormMatrix.Concat(formMatrix);
   while (pos) {
-    pPageObj = pFormObj->m_pForm->GetNextObject(pos);
+    pPageObj = pFormObj->m_pForm->GetPageObjectList()->GetNextObject(pos);
     if (pPageObj) {
       if (pPageObj->m_Type == CPDF_PageObject::TEXT) {
         ProcessTextObject((CPDF_TextObject*)pPageObj, curFormMatrix, pos);
       } else if (pPageObj->m_Type == CPDF_PageObject::FORM) {
         ProcessFormObject((CPDF_FormObject*)pPageObj, curFormMatrix);
       }
     }
     pPageObj = NULL;
   }
 }
@@ skipping 928 matching lines @@
   return TRUE;
 }
 
 FX_BOOL CPDF_TextPage::IsSameAsPreTextObject(CPDF_TextObject* pTextObj,
                                              FX_POSITION ObjPos) {
   if (!pTextObj) {
     return FALSE;
   }
   int i = 0;
   if (!ObjPos) {
-    ObjPos = m_pPage->GetLastObjectPosition();
+    ObjPos = m_pPageObjectHolder->GetPageObjectList()->GetTailPosition();
   }
-  CPDF_PageObject* pObj = m_pPage->GetPrevObject(ObjPos);
+  CPDF_PageObject* pObj =
+      m_pPageObjectHolder->GetPageObjectList()->GetPrevObject(ObjPos);
   while (i < 5 && ObjPos) {
-    pObj = m_pPage->GetPrevObject(ObjPos);
+    pObj = m_pPageObjectHolder->GetPageObjectList()->GetPrevObject(ObjPos);
     if (pObj == pTextObj) {
       continue;
     }
     if (pObj->m_Type != CPDF_PageObject::TEXT) {
       continue;
     }
     if (IsSameTextObject((CPDF_TextObject*)pObj, pTextObj)) {
       return TRUE;
     }
     i++;
@@ skipping 666 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);
 }